{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "05b6b1ea-cdf2-41c6-8b26-e2fcb48e3fbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.io import loadmat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ba9c637a-d64b-46c2-9980-e66e808ea384",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load your data (assuming CN.mat is your MATLAB data file)\n",
    "data = loadmat('./data/CN.mat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5ce6f28d-f3d4-4e3d-af22-bcbe1b775235",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['__header__', '__version__', '__globals__', 'X'])\n",
      "['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']\n",
      "Help on dict object:\n",
      "\n",
      "class dict(object)\n",
      " |  dict() -> new empty dictionary\n",
      " |  dict(mapping) -> new dictionary initialized from a mapping object's\n",
      " |      (key, value) pairs\n",
      " |  dict(iterable) -> new dictionary initialized as if via:\n",
      " |      d = {}\n",
      " |      for k, v in iterable:\n",
      " |          d[k] = v\n",
      " |  dict(**kwargs) -> new dictionary initialized with the name=value pairs\n",
      " |      in the keyword argument list.  For example:  dict(one=1, two=2)\n",
      " |  \n",
      " |  Built-in subclasses:\n",
      " |      StgDict\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      True if the dictionary has the specified key, else False.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __ior__(self, value, /)\n",
      " |      Return self|=value.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the dict keys.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      D.__sizeof__() -> size of D in memory, in bytes\n",
      " |  \n",
      " |  clear(...)\n",
      " |      D.clear() -> None.  Remove all items from D.\n",
      " |  \n",
      " |  copy(...)\n",
      " |      D.copy() -> a shallow copy of D\n",
      " |  \n",
      " |  get(self, key, default=None, /)\n",
      " |      Return the value for key if key is in the dictionary, else default.\n",
      " |  \n",
      " |  items(...)\n",
      " |      D.items() -> a set-like object providing a view on D's items\n",
      " |  \n",
      " |  keys(...)\n",
      " |      D.keys() -> a set-like object providing a view on D's keys\n",
      " |  \n",
      " |  pop(...)\n",
      " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      " |      \n",
      " |      If key is not found, default is returned if given, otherwise KeyError is raised\n",
      " |  \n",
      " |  popitem(self, /)\n",
      " |      Remove and return a (key, value) pair as a 2-tuple.\n",
      " |      \n",
      " |      Pairs are returned in LIFO (last-in, first-out) order.\n",
      " |      Raises KeyError if the dict is empty.\n",
      " |  \n",
      " |  setdefault(self, key, default=None, /)\n",
      " |      Insert key with a value of default if key is not in the dictionary.\n",
      " |      \n",
      " |      Return the value for key if key is in the dictionary, else default.\n",
      " |  \n",
      " |  update(...)\n",
      " |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
      " |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
      " |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
      " |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
      " |  \n",
      " |  values(...)\n",
      " |      D.values() -> an object providing a view on D's values\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  __class_getitem__(...) from builtins.type\n",
      " |      See PEP 585\n",
      " |  \n",
      " |  fromkeys(iterable, value=None, /) from builtins.type\n",
      " |      Create a new dictionary with keys from iterable and values set to value.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(data.keys())\n",
    "\n",
    "\"\"\" \n",
    "列出对象的所有方法和属性。\n",
    "\"\"\" \n",
    "obj_methods_and_attributes = dir(data)  \n",
    "print(obj_methods_and_attributes)\n",
    "\n",
    "help(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "754d9507-23af-4992-ad32-26a4e8763ed3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[116.4052   39.9049 ]\n",
      " [117.1901   39.1255 ]\n",
      " [114.5024   38.0454 ]\n",
      " [112.5492   37.857  ]\n",
      " [111.6708   40.8183 ]\n",
      " [123.429    41.7967 ]\n",
      " [125.3245   43.8868 ]\n",
      " [126.6424   45.7569 ]\n",
      " [121.4726   31.2317 ]\n",
      " [118.7674   32.0415 ]\n",
      " [120.1535   30.2874 ]\n",
      " [117.283    31.8611 ]\n",
      " [119.3062   26.0753 ]\n",
      " [115.8921   28.6764 ]\n",
      " [117.0009   36.6758 ]\n",
      " [113.6654   34.7579 ]\n",
      " [114.2985   30.5843 ]\n",
      " [112.9822   28.194  ]\n",
      " [113.2806   23.1251 ]\n",
      " [108.32     22.824  ]\n",
      " [110.3311   20.0319 ]\n",
      " [106.5049   29.5331 ]\n",
      " [104.0657   30.6594 ]\n",
      " [106.7134   26.5783 ]\n",
      " [102.7122   25.0406 ]\n",
      " [ 91.13221  29.6603 ]\n",
      " [108.948    34.2631 ]\n",
      " [103.8235   36.058  ]\n",
      " [101.7789   36.6231 ]\n",
      " [106.2781   38.4663 ]\n",
      " [ 87.6177   43.79281]\n",
      " [121.509    25.0443 ]\n",
      " [114.1733   22.32   ]\n",
      " [113.549    22.1989 ]]\n"
     ]
    }
   ],
   "source": [
    "X = data['X'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31c1005e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4707eefb-beca-4df5-951b-c2562094508e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dsxy2figxy(axis, x, y):\n",
    "    \"\"\"\n",
    "    数据坐标系转换为图形坐标系\n",
    "    \"\"\"\n",
    "    axun = axis.get_units()\n",
    "    axis.set_units('normalized')\n",
    "    axpos = axis.get_position()\n",
    "    axlim = axis.axis()\n",
    "    axwidth = axlim[1] - axlim[0]\n",
    "    axheight = axlim[3] - axlim[2]\n",
    "\n",
    "    if len(x) == 1 and len(y) == 1:\n",
    "        x = [x, x]\n",
    "        y = [y, y]\n",
    "\n",
    "    x = np.array(x)\n",
    "    y = np.array(y)\n",
    "\n",
    "    if len(x.shape) == 1:\n",
    "        x = x.reshape((1, x.size))\n",
    "\n",
    "    if len(y.shape) == 1:\n",
    "        y = y.reshape((1, y.size))\n",
    "\n",
    "    pos = np.column_stack([x, y])\n",
    "    pos[:, 0] = (pos[:, 0] - axlim[0]) / axwidth * axpos.width + axpos.x0\n",
    "    pos[:, 1] = (pos[:, 1] - axlim[2]) / axheight * axpos.height + axpos.y0\n",
    "    pos[:, 2] = pos[:, 2] * axpos.width / axwidth\n",
    "    pos[:, 3] = pos[:, 3] * axpos.height / axheight\n",
    "\n",
    "    axis.set_units(axun)\n",
    "    return pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f1486aa0-48d2-4750-8922-8ef77c966c6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(a):\n",
    "    row = a.shape[0]\n",
    "    D = np.zeros((row, row))\n",
    "    for i in range(row):\n",
    "        for j in range(i + 1, row):\n",
    "            D[i, j] = np.sqrt(np.sum((a[i, :] - a[j, :]) ** 2))\n",
    "            D[j, i] = D[i, j]\n",
    "    return D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ee758dc9-bf68-4507-b59a-1380812ef176",
   "metadata": {},
   "outputs": [],
   "source": [
    "def intercross(a, b):\n",
    "    L = len(a)\n",
    "    r1 = np.random.randint(1, L+1)\n",
    "    r2 = np.random.randint(1, L+1)\n",
    "    \n",
    "    if r1 != r2:\n",
    "        a0, b0 = a.copy(), b.copy()\n",
    "        s, e = min(r1, r2), max(r1, r2)\n",
    "        for i in range(s, e):\n",
    "            a1, b1 = a.copy(), b.copy()\n",
    "            a[i] = b0[i]\n",
    "            b[i] = a0[i]\n",
    "            x = np.where(a == a[i])[0]\n",
    "            y = np.where(b == b[i])[0]\n",
    "            i1 = x[x != i]\n",
    "            i2 = y[y != i]\n",
    "            if len(i1) > 0:\n",
    "                a[i1[0]] = a1[i]\n",
    "            if len(i2) > 0:\n",
    "                b[i2[0]] = b1[i]\n",
    "    return a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "81f1ebb8-063b-4229-a6fa-ba7f9cece6de",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reins(Chrom, SelCh, ObjV):\n",
    "    NIND = Chrom.shape[0]\n",
    "    NSel = SelCh.shape[0]\n",
    "    TobjV = np.argsort(ObjV)\n",
    "    Chrom = np.vstack((Chrom[TobjV[:NIND-NSel], :], SelCh))\n",
    "    return Chrom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9fbe206f-23d6-4dfb-936e-a80bb81a9408",
   "metadata": {},
   "outputs": [],
   "source": [
    "def select(Chrom, FitnV, GGAP):\n",
    "    NIND = Chrom.shape[0]\n",
    "    NSel = max(int(np.floor(NIND * GGAP + 0.5)), 2)\n",
    "    ChrIx = sus(FitnV, NSel)\n",
    "    SelCh = Chrom[ChrIx, :]\n",
    "    return SelCh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f9f2d857-ca51-441a-b1d3-8d862cd1f464",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sus(FitnV, Nsel):\n",
    "    Nind = FitnV.shape[0]\n",
    "    cumfit = np.cumsum(FitnV)\n",
    "    trials = cumfit[Nind-1] / Nsel * (np.random.rand() + np.arange(Nsel))\n",
    "    Mf = np.tile(cumfit, (Nsel, 1))\n",
    "    Mt = np.tile(trials.reshape(Nsel, 1), (1, Nind))\n",
    "    NewChrIx = np.where(Mt < Mf)\n",
    "    NewChrIx = (NewChrIx[0], NewChrIx[1])\n",
    "    shuf = np.argsort(np.random.rand(Nsel))\n",
    "    NewChrIx = (NewChrIx[0][shuf], NewChrIx[1][shuf])\n",
    "    return NewChrIx[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d894b85a-d803-4b9f-91e1-53f155e6f629",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Fitness(len):\n",
    "    return 1.0 / len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4a7e8843-6923-4a25-a854-821fc219169d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def InitPop(NIND, N):\n",
    "    Chrom = np.zeros((NIND, N))\n",
    "    for i in range(NIND):\n",
    "        Chrom[i, :] = np.random.permutation(N)\n",
    "    return Chrom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3183f163-baba-4c22-a724-9403979102f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Mutate(SelCh, Pm):\n",
    "    NSel, L = SelCh.shape\n",
    "    for i in range(NSel):\n",
    "        if Pm >= np.random.rand():\n",
    "            R = np.random.permutation(L)\n",
    "            SelCh[i, R[0:2]] = SelCh[i, R[1::-1]]\n",
    "    return SelCh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "d4b9d7a7-29c9-46d1-b781-446faf7f72eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def OutputPath(R):\n",
    "    R = np.append(R, R[0])\n",
    "    p = ' -> '.join(map(str, R))\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "1dd87bde-8a36-4d8d-9335-22e79d37774b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def path_length(D, Chrom):\n",
    "    \"\"\"\n",
    "    计算路径长度\n",
    "    \"\"\"\n",
    "    NIND = Chrom.shape[0]\n",
    "    len = np.zeros(NIND)\n",
    "    for i in range(NIND):\n",
    "        p = np.append(Chrom[i, :], Chrom[i, 0])\n",
    "        i1 = p[0:-1]\n",
    "        i2 = p[1:]\n",
    "        len[i] = np.sum(D[i1.astype(int), i2.astype(int)])\n",
    "    return len\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "637bcab6-ec22-482d-9d75-711904859d1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Recombin(SelCh, Pc):\n",
    "    NSel = SelCh.shape[0]\n",
    "    for i in range(0, NSel, 2):\n",
    "        if Pc >= np.random.rand():\n",
    "            SelCh[i, :], SelCh[i+1, :] = intercross(SelCh[i, :], SelCh[i+1, :])\n",
    "    return SelCh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "db4e82d6-6c20-4a59-b183-b78fae8242c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def DrawPath(chrom, X):\n",
    "    \"\"\"\n",
    "    画路径函数\n",
    "\n",
    "    Parameters:\n",
    "    - chrom: 待画路径\n",
    "    - X: 各城市坐标位置\n",
    "    \"\"\"\n",
    "    R = chrom\n",
    "\n",
    "    plt.figure()\n",
    "    plt.gca().set_prop_cycle(None)\n",
    "\n",
    "    # 修改 DrawPath 函数中的索引\n",
    "    plt.plot(np.concatenate([X[R.astype(int), 0], [X[R[0].astype(int), 0]]]), np.concatenate([X[R.astype(int), 1], [X[R[0].astype(int), 1]]]), 'o', color=[0.5, 0.5, 0.5])\n",
    "    plt.plot(X[R[0].astype(int), 0], X[R[0].astype(int), 1], 'rv', markersize=20)\n",
    "    plt.plot(X[R[-1].astype(int), 0], X[R[-1].astype(int), 1], 'rs', markersize=20)\n",
    "    plt.text(X[R[0].astype(int), 0] + 0.05, X[R[0].astype(int), 1] + 0.05, f' 起点 {R[0]}', color=[1, 0, 0])\n",
    "    plt.text(X[R[-1].astype(int), 0] + 0.05, X[R[-1].astype(int), 1] + 0.05, f' 终点 {R[-1]}', color=[1, 0, 0])\n",
    "\n",
    "    for i in range(1, X.shape[0]):\n",
    "        if R[0] != i and R[-1] != i:\n",
    "            plt.text(X[i, 0] + 0.05, X[i, 1] + 0.05, str(i), color=[1, 0, 0])\n",
    "\n",
    "    A = np.concatenate([X[R.astype(int), :], [X[R[0].astype(int), :]]])\n",
    "    row = A.shape[0]\n",
    "\n",
    "    for i in range(1, row):\n",
    "        arrow_x, arrow_y = plt.gca().transData.transform(A[i-1:i+1, :].T).T  # 使用transData进行坐标转换\n",
    "        plt.arrow(arrow_x[0], arrow_y[0], arrow_x[1] - arrow_x[0], arrow_y[1] - arrow_y[0], head_width=0.05, color=[0, 0, 1])\n",
    "\n",
    "    plt.gca().set_prop_cycle(None)\n",
    "    plt.xlabel('横坐标')\n",
    "    plt.ylabel('纵坐标')\n",
    "    plt.title('轨迹图')\n",
    "    plt.box(True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "4f69b464-eba1-4d88-8d5a-341a10312946",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse(SelCh, D):\n",
    "    N, L = SelCh.shape\n",
    "    SelCh1 = SelCh.copy()\n",
    "\n",
    "    for i in range(N):\n",
    "        r1, r2 = np.random.choice(L, 2, replace=False)\n",
    "\n",
    "        try:\n",
    "            if r1 != r2:\n",
    "                min_inverse = min(r1, r2)\n",
    "                max_inverse = max(r1, r2)\n",
    "\n",
    "                # 检查 SelCh1[i, min_inverse:max_inverse+1] 是否为空\n",
    "                if min_inverse != max_inverse and np.any(SelCh1[i, min_inverse:max_inverse+1]):\n",
    "                    SelCh1[i, min_inverse:max_inverse+1] = SelCh1[i, max_inverse:min_inverse-1:-1]\n",
    "                elif max_inverse < L and not np.all(SelCh1[i, min_inverse:max_inverse+1] == 0):\n",
    "                    SelCh1[i, min_inverse:] = SelCh1[i, max_inverse::-1]\n",
    "\n",
    "        except ValueError as e:\n",
    "            # print(f\"Error processing data at index {i}: {e}\")\n",
    "            # print(f\"SelCh1[{i}]: {SelCh1[i]}\")\n",
    "            continue\n",
    "    \n",
    "    ObjV1 = path_length(D, SelCh1)\n",
    "    index = ObjV1 < path_length(D, SelCh)\n",
    "    SelCh[index, :] = SelCh1[index, :]\n",
    "\n",
    "    return SelCh\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "9917c154-ff39-426b-998f-f7361d6c9086",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial random solution:\n",
      "22.0 -> 31.0 -> 11.0 -> 9.0 -> 23.0 -> 26.0 -> 14.0 -> 29.0 -> 27.0 -> 7.0 -> 0.0 -> 13.0 -> 20.0 -> 33.0 -> 21.0 -> 4.0 -> 3.0 -> 30.0 -> 8.0 -> 2.0 -> 18.0 -> 28.0 -> 15.0 -> 19.0 -> 32.0 -> 16.0 -> 12.0 -> 25.0 -> 5.0 -> 24.0 -> 17.0 -> 10.0 -> 1.0 -> 6.0 -> 22.0\n",
      "Total distance: [461.17220155]\n",
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Best solution:\n",
      "25.0 -> 24.0 -> 19.0 -> 20.0 -> 33.0 -> 32.0 -> 18.0 -> 17.0 -> 13.0 -> 16.0 -> 11.0 -> 9.0 -> 10.0 -> 12.0 -> 31.0 -> 8.0 -> 5.0 -> 6.0 -> 7.0 -> 0.0 -> 1.0 -> 14.0 -> 15.0 -> 2.0 -> 4.0 -> 3.0 -> 26.0 -> 21.0 -> 23.0 -> 22.0 -> 29.0 -> 27.0 -> 28.0 -> 30.0 -> 25.0\n",
      "Total distance: 165.91171138775252\n",
      "-------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHFCAYAAADv8c1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACoCklEQVR4nO2dd3gVxdfHTwIkBAihE0JXOqEoKB2kCChFsaJUwQJKkfKqgIgVsPywUhSxgAiogIIU6U1CDSX0HkoSAiEkQEi95/3juJmZLTd7k5vclPN5nnmyO333qvt15sw5XoiIwDAMwzAMwzjF29MTYBiGYRiGyQuwaGIYhmEYhrEBiyaGYRiGYRgbsGhiGIZhGIaxAYsmhmEYhmEYG7BoYhiGYRiGsQGLJoZhGIZhGBuwaGIYhmEYhrEBiyaGYRiGYRgbFPb0BBiGYXKS48ePQ6tWrZzW2b59O7Rr185pnb1790JqamqGfe3duxdq167t8jwZhsl9sGhiGKZAkZaWBsHBwbBjxw7T8rZt24KXl1eGddLS0mz1lZaW5ra5MwzjWXh7jmEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMABexmGKVAUKlQIDh06BKVKlTIt1wLxZlTH29vbVl/e3vz/pgyTX/BCRPT0JBiGYRiGYXI7/L9ADMMwDMMwNmDRxDAMwzAMYwMWTQzDMAzDMDZgQ3A34nA4ICIiAvz9/cHLy8vT02EYhmEYxgaICLdu3YKgoCCnhzdYNLmRiIgIqFq1qqenwTAMwzBMJrh06RJUqVLFspxFkxvx9/cHAHrpJUuW9PBsGIZhGIaxQ3x8PFStWjX9O24FiyY3om3JlSxZkkUTwzAMw+QxMjKtYUNwhmEYhmEYG7BoYhiGYRiGsQGLJoZhGIZhGBuwaGIYhmEYhrEBiyaGYRiGYRgbsGhiGIZhGIaxAYsmhmEYhmEYG7BoYhiGYRiGsQGLJoZhGIZhGBuwaGIYhmEYhrEBiyaGYRiGYRgbsGhiGIZhGIaxAYsmhmEYhmEYG7BoYhiGYZhsJCYG4MknAUJDPT0TJquwaGIYhmGYbOLkSYBy5QCWLQNISPD0bJiswqKJYRiGYbKBTZsA6tWj65kzAdq29ex8mKzDoolhGIZh3Mz33wN07kzXa9cCvPqqZ+eTFVJSAK5f9/QscgeFPT0BhmEYhslPjBsHMGMGXR89CtCggWfnkxVOnhSrZYienUtugEUTwzAMw7iJTp0ANm+m66tXASpU8Ox8ssLs2WKF7M03PTuX3AKLJoZhGIbJIogA/v4Ad+7Q/d27AEWLenZOmQUR4IEHAPbvp/t//wVo3dqzc8otsGhiGIZhmCyQnAzg60vXhQqRDZCXl2fnlFliYui0n0Z8PIlBhmBDcIZhGCZPcfs2gMPh6VkQMTFCMLVuDZCamncF0/r1QjA9/LBYPWMELJoYhmGYPEPz5vQhP3XK0zMRPpgAAF57jbax8iqvvALQtStdL1gAsG6dZ+eTW+HtOYZhGCZP0LQpwKFDdF2njkenAps2CZcCs2YBDB/u2flkFnlrEQDgwgWA6tU9Np1cD680MQzDMLmehg2FYEpLA/D24NdL9sH0zz95VzAdPy4EU6lStLXIgsk5LJoYhmGYXE2dOgDHjtG1w+FZwTRuHMBLL9H10aNiSyuv8fXXwn/UxIkAsbFkxM44h7fnGIZhmFxLjRoA4eF07XB41sg6P/hgQqRtzsOH6T4kBKBlS49OKU/BK00MwzCMx2jVCmD0aPOyypVzh2BCBChRQgimu3ddF0yjRtH8Nd9HnuD6dVql0wTTrVssmFyFRRPDMAzjESZOBNi1S9gqyZQvDxARQdeeFExJSSQ07tyh7SuHw3WnlS+9RNthAAB167p/jnZYu5beKQDAo48KIci4BosmhmEYJseJjgaYNo2uN25UywICRIBYTwqm69eFQMqsD6b+/clwHID8S3lCqAwdCvDII3S9aBHAqlU5P4f8Ats0MQzDMDlOxYr0d80a1QDZzw8gMZHEiScdWJ44AVC/Pl2/9hrAN9+43seTTwIsW0bXCQn0bDlJUpK6KjZjBsCzz+bsHPIbvNLEMAzD5Cj/+x/9DQoC6N5d5BcqRIKpSBHPCqaNG4VgmjUrc4LpkUeEYEpMzHnBdPSoEEzFi9PfsWPzrrfy3AKLJoZhGCbHiIsDGD+ers+fp7+IYmWpeHFyuOgp5s4F6NKFrjPrg6ljR7IhAjA6j8wJvvgCIDiYrsuWFUGE9bZjMTGUGPuwaGIYhmFyjFKl6O+SJQA+PiSYNL9LpUuT3Y+nGDMG4OWX6frYscz5YGrRAmDLFrpOSaFVs5wCkVbIxowReZooSkgAaNxY5H/7LYWAeeGFnJtffoBFE8MwDJMj/Pgj/S1cGOCZZ1TBVLEiwI0bnptbx460QgNARura9pwrNGoEsGcPXaem0nPmFNHR9C5PnFDze/ak9yxvDz75JMCwYXT93nsZ9/3nnwD33gtw8KC7Zpt3YUNwhmEYJtu5exdgyBC6vnlTFUxVqwJcvOiZeSHSluDdu3R/967rLgUASFScO0fXOR3mZdUqEkfaPM6epesFC+j0nkZamirkYmPFyp8VPXuK03Zly7ptynkWFk0MwzBMtqM5g5wzB6BYMSEq7rlHfORzGvl0WZEidJ8ZQ+nAQPIQDpDzLhIGDQKYP5+ufX3Fuzx7lt6txrVr4jcICCDB5GyeN2/SdqlGVJQ48ViQ4e05hmEYJltZvlzYKr38shBMdet6TjDJPpjatiWD7cyIHX9/zwgmzS2DJpgASPQBkC2VLJh27hSCacgQEkTO5rl2rRBMDz5Iz8WCiWDRxDAMw2QbKSkATzxB11oYDwCAhg2N9jc5xYkTwjv2yJEA27e73gciuUi4fZv+aicAs5uUFAqDotkolSkjyl56ieYhb8F98QVAmzZ0vWABwLx5zvt/9lnhCPOnnwB277b/XDdvAjz1lAg3AwDwySf0fjLzjnMjvD3HMAzDZBv16tHfDz+k01oAAPfdBxAa6pn5bNwoXArMni0Mol1BtscqUYJiuOUEv/4K0K+fuG/cWMSRW7WKwqPIdOsGsG4dXR85QkLVilu3AEqWFPeXL1PsP7tMm0ZhcQAA+vQhw3R5dapGDft95WZYNDEMwzDZwqZNwjj67bfp74MP0uqFJ5g7V7gUWLcO4OGHXe9DFkyBgQCRke6bnzOeegpg6VI1TxNMkZE0F43UVNXVQXw8bSNasXkzQKdOdN2gAQksu6tLV64AVKki7v/4g+alGaBXrUpbsFl1vYAI8NFHFM5Gm6sn4O05hmEYxu04HACdO6t5bdp4TjDpfTBlRjA5HKoBe04IJs3WSi+YAAAqVaI5yYIpIkIIlCpVqNyZYBoyRIiQOXPIk7gmmGJinHtmf+01IZhq1wa4cIHE3fvvU97q1XQqMquC6dw5eu+TJwOsWJG1vrIKiyaGYRjG7bRrp9537AiwY4dn5uIOH0xpaSJGXnBwzhiwnz2rehO//35x/fbbJJDkFaEtW8SW2ogRAJcuWa8YJSRQmeY76/x5gFdeoeu0NCorV878OY8fp/JZs+h+61aAxx4TW3D16pHtlWYblRXefpvcKAAAPP64+B09BW/PMQzDMG5l3z46saXRtSuFJMlp3OWDSd7uatECYNcu983RikWLAJ5/XtwHBws7sB07hHG3hmxT9Mcf5MDSip07Rftq1UgwaStosbHCuLxsWYBatUQ7RIDevQH+/pvuu3ShLc+aNUWdTZtIpGaV+HhyjSDPuVWrrPebVXiliWEYhnEbiAAPPCDue/TwjGBKSiIhcPeuCACcGcEkh0Lp2DFnBNPTT6uCCYDsjADohJpeMLVpIwTTqVPOBdPIkaL9558DhIcLwXT4sBBM/frRaUdtpSokhOppgunQIdqS0wRT8+a0QuUOwbRkiRBMFSvSb5AbBBMArzQxDMMwbuSxx8T144+Tj6ac5vp14VKgbdvMH3eXnV8+8gjZ6GQnKSkUj0+jYkXhA+qBB0SIFg19MOA7d8hxqBmJiWoolVOnSPRoyCtbc+aoW3X33y+Mzl94AWDSJHUFymzlSyM8nFwXvPaaOD1pRVoaQJ064vDAzz8DDBzovE1OwytNDMMwjFs4eBBg5Uq6fvppzwim48ez7oMJQN3Ke/LJ7BdM586pgqlrVyGYPv6YTrUdOiTKL14Ugql+fVpJsxJM+/apfp1SUsink5cXGcW//roQTDt3CsH099/k80kTTBcu0EqiJpgeeojGNRNMiOTzqUYNgHffJdHmjP37aSxNMN24kfsEEwAAIOM24uLiEAAwLi7O01NhGIbJURISEOlTifjoo56Zw/r1Yg6zZ2e+n9u3RT/9+9trk5qKeOgQ/XWVRYvEeACIVauK6wULxPWWLVR/zRqR9+abzvt+4w1R96OPEA8cUMeqU0dcR0ZSm4QExIAAkf/OO4jHjqnt9u61HnP7drVuSIjzOfbrJ+qOHWv3rbkXu99vFk1uhEUTwzAFEVkwBQV5Zg7ffivmsH595vuJjxf9vPSSvTayyIqPd228xx9XBYacJk8W13PnUv1Jk0Te338jrl5N1198ofabnKz2deQIYp8+4n7QILU8KYnaff+9mn/tGuJTT6mC2OEwf5akJMTq1UXdgQOdP3tEhDrWiROuvTt3wqLJA7BoYhimoCELBgDrD2p2Mnq0GP/Yscz3Exsr+hk50l4b+cP/1FOU53CQyDlzxrqdXtS0aSOuH3tMXQE6epTaNG4s8s6dQ3zySXG/ebPo+9AhkV+kCGJYmDrWli3q/dy5iDduqHmzZ6v9ACAePGj9PPPmqXUvXXL+3v73P1G3bVvP/HMjw6LJA7BoYhimIHHrlvqh3Lkz5+fQoYO6KpJZrl8X/fzf/9lrc+SIuiqEiHjzpsj79VfzdufOqe+tVy9x/d13atndu+pKHgDi1avq/ZUrou933xX548cjDh0q7vv0Qdy2zbiiJbfx8yMh3L27yHvmGet3oJ+LfsVLj/5Z/vnH3rvOblg0eQAWTQzDFBTkbSwAxPvvz9nxHQ5EX18xfmJi5vuSP/zvvGOvjWw/9dNPlLd3r8jr3t28nWyjBKA+w9Kl4rprV6p/5ozIa96cRIZ237SpWKFJSUEsXtwoiLR04ADiV1+peUWLqvfLliHu2aPmOVu5GzVK1AsIQLxzx/k707YSARC9vUkQ5hZYNHkAFk0MwxQE5NUULWXGADqzJCaqoiMrWzvy9trUqfbayFtRmzZR3hdfqFtbZsirNxUrqu9vyhR1uwwRcflykffee4jPPSfu580T/R4/bi2WOnSg9/P002p+lSriul492i5s317kDR5s/fz6bbuMVoscDsQWLeyvRnkCFk0egEUTwzD5HdnuxxNbLNeuiXHbt89aXxcvir4++8xem4kTjasw8hbhgQPGNnr7Jdmw+pVXVPul4GBqM3asyPvrL7W9bC/0ySfWgmnHDhIszlagtm2jenKelS1Waqoqfrp1y1iw6k/daSf0chssmjwAiyaGYfIzMTHi49epk1ixyCnkD/CoUVnr6/x50dc339hrI590i4yk7SVZEJidnDt7Vq3z8MPi+vffjSLm+ecRa9YU94sXi+sGDYRISUszrlZpqVEjKtdvocqpa1cSQfffL/JefdX62ZctU9vbOekmG+hndJLO07Bo8gAsmhiGya/IhtLjx4tr7ah6diPbEM2Zk7W+Tp8WfX3/vb0299wj2ty5g3jqlLivX998xWXOHGvR8vffxrxVq9T7/v3F9bffin5lOyerVb8TJ6zrhIUhbtyo5oWHmz93XJxa7+23M35XsrgGQNy/39479iQsmjwAiyaGYfIj0dHiA/jee+L6t99yZnx3+WBCVFer5s/PuH5amioAUlNVZ5RTppi3a9dO1GnZUlxXraq+Qy1PdgsgtwVAvHBB9PvNN+ZCqHJl2gZENG7naenFF8lgvG5dkac/KZiWRvZSly8jfvih2v7GjYzf1w8/iPp161J/eQEWTR6ARRPDMPkN+WTZRx+Jj6KPT86M7y4fTIiIhw+LvpYsybi+fDy+alXKGzhQ5Mm+kTRSUlShMXiwuJ48GbF2bbX8jz/ULbhhw8T1PfcI0eFwIN57r7kYWrpUjC87xNSvJMmn1wBUVwWIJM7M2i5enPG7Sk5GLFs25wW1u2DR5AFYNDEMk5+IjBQfwY8/VkVERsfL3YG7fDAh0haR1tfy5RnXl8Vir160wuTlJfKuXjW20Rs9P/igum2mFyMJCWQIrt337CmuZTur8HBzMePrqx7bb93aWOfdd0nQyKflzNwq/PSTsW2TJiQCM0JvSO6qV/TcQJ4TTVOnTkUAwNGjR6fnORwOnDJlClaqVAmLFi2KHTp0wCNHjijtEhMTccSIEVi2bFksVqwY9urVCy/pXJHeuHED+/fvjyVLlsSSJUti//79MTY2VqkTHh6OPXv2xGLFimHZsmVx5MiRmOTiZj2LJoZh8gtXroiPoHayrEQJupfta7IDd/pgQkTctUv0tWpVxvXlI/xvvKG6JfDzM99ymjZN1ClVShURcqw4AHJJ4HAgli9vLobOnhX96sOaaOmHH0Qd/eqWlmJijAbc0dHGueu3AwEQ9+2z925lx5xWW5V5gTwlmvbs2YM1atTAxo0bK6Jp+vTp6O/vj0uXLsWwsDB89tlnsVKlShgvydhhw4Zh5cqVcf369RgaGoodO3bEJk2aYKrkNKR79+4YHByMO3fuxJ07d2JwcDD27NkzvTw1NRWDg4OxY8eOGBoaiuvXr8egoCAcMWKES8/BoolhmPzApUviQ6j51JE/vtmJO30wIaoesO3YQ23eLOp/951qgP7ii+ZtmjQRdeQTdi1aIL7wgipGbtww93MFQHH76tShVSaHQ+3XaiVHtjfTUufOtAIli7ePPzbOWx86BcB+vD359CEAeTnPy+QZ0XTr1i2sXbs2rl+/Hjt06JAumhwOBwYGBuL06dPT6yYmJmJAQADO+e/oxM2bN7FIkSK4WNpwvXLlCnp7e+PatWsREfHYsWMIALhr1670OiEhIQgAeOK/M5OrV69Gb29vvCJt8C5atAh9fX1dEkAsmhiGyevIvou0LSLZz5AdY+DM4k4fTIjqCbGtWzOuL3vr/ucfxAkTxP0ffxjrJyWpwmHIEHH99deqx23tOL/sGLJGDXEtO5+Ug/LK6fXX1fFlD+TyKtavvxpXnGRSUxE3bDC2jYiw915lQ/YePey1ye3kGdE0cOBAfP2/fxJk0XT27FkEAAwNDVXq9+7dGwf+5/Bh48aNCAB4Q/dvcePGjfGd/zZt582bhwEBAYZxAwIC8If/1jcnT56MjRs3Vspv3LiBAICbNHevJiQmJmJcXFx6unTpEosmhmHyLLIhsHysXztuL/0/rNtxpw8mRHVLzE5MPDn+2qFDqq8kebtMY+dOVXDIAkhvH6Q5izSzGwIgo3rtWjZ8l9P58+r4n31mrLNuHWLhwuL+q6+M8379dWO7mTPtvVN9rEE7QjSvYFc0FQYPsnjxYggNDYW9e/cayqKiogAAoGLFikp+xYoVITw8PL2Oj48PlC5d2lBHax8VFQUVKlQw9F+hQgWljn6c0qVLg4+PT3odM6ZNmwbvvfdeRo/JMAyT6zl/HuCee+h67lyAF1+k640bAc6do+s338yesdevB+jala7nzAF45ZWs9bdiBcBjj9H13r0AzZs7r//ccwCLF9P18eMA9euLssREAF9ftf7YsQCff07XdeoAnDoFcOEC3XfoADB4MF1XrQpw8SJdDxgA8Msvaj+lSgHcvAmQnEz3LVsCfPmlWkfuQ6N+fYATJ9S8jz8W7xAAIC4OoGRJce9wAFSoABATI/LKlQO4dAmgaFHIkGXLAJ58kq5Llwa4ehWgSJGM2+U3vD018KVLl2D06NHwyy+/QFEnv5iXl5dyj4iGPD36Omb1M1NHz4QJEyAuLi49Xbp0yem8GIZhciNnzwrB9MMPQjA5HABdutB1ZGT2jP3tt+Jjv2FD1gXTH38IwXTwYMaCKThYCKZt24Rg6taN1lP0gqlqVSGYBg4kwQQgnmHrVvr7wQckdhwOAD8/o2AKCiLBBACg/b/3rl1qnenTVcEUFgbg5WUUTABC0M6dS/OWBdP16wCFCqmCacMGgGvXMhZMDgdAgwZCMH3/PcCNGwVTMAEAeGylaf/+/RAdHQ3NmjVLz0tLS4Nt27bBN998AydPngQAWgWqVKlSep3o6Oj0VaHAwEBITk6G2NhYZbUpOjoaWrdunV7n6tWrhvGvXbum9LN7926lPDY2FlJSUgwrUDK+vr7gq/83imEYJg9x6hRA3bp0PX8+rYhotGlDf8ePBwgMdP/Yo0YBfP01XR8/DlCvXtb6W7gQoH9/uj56lD72VjgcJCQ0ZswAaN+ermfNAhg+XK1/8yatsGg8/zy9LwCARx4BWLNGlGlj37gBULas+fgREfR33jyAoUON5fL7QCRRtmGD9fN4ewPExwMUL67mb9oE0LmzuK9bl/rOYO0BAEh03nefuL9+3fp5Cgw5sFVoSnx8PIaFhSmpefPm2L9/fwwLC0s3BP9YMvlPSkoyNQRfInkpi4iIMDUE3717d3qdXbt2mRqCR0hWcIsXL2ZDcIZh8jXy0fqFC9Wy3btFWXYgH3PPqg8mRNUT9cmTzuvKMeMqVEDs2FHcmwXc/fNPUe7trdoN6ZPmN8nMSLtIEXE9fDgFvDXrQ/Z2s3279VhaWrDA/DmffFKt9+efZBS+Z0/GnrrlU39mB8kPHqT3MHu2837yCnnGEFxGNgRHJJcDAQEBuGzZMgwLC8PnnnvO1OVAlSpVcMOGDRgaGoqdOnUydTnQuHFjDAkJwZCQEGzUqJGpy4HOnTtjaGgobtiwAatUqcIuBxiGybccPSo+inrv2A6HcyPorOBwqOIhqz6YEBFnzbI/XzmGnhZ0WEtmThmfekqUy84qvb3Vtt26mc/HLOmNyLUkB7VNSaGYds76KVlSdW6pYeZKICGBQqZo91aiKSpKbTdnDglc2Rv788+LcrNThXmRfCGaNOeWgYGB6Ovri+3bt8ewsDClzd27d3HEiBFYpkwZ9PPzw549e+LFixeVOjExMdivXz/09/dHf39/7Nevn6lzyx49eqCfnx+WKVMGR4wYgYku/tvMoolhmLyAHE7E7KPXu7fxI+4OZB9Mfn5Z98GESH6ktD6tgs5qyEF2Bw0S13XrGueSlqaeahs61Fq8yEF/+/SxrtepE+LKleZlf/0l+li+POPVJSuxIgsjAFptkuPa6ceS+eorUadZM9XBaHi4MczK0aMZ/Tp5hzwpmvI6LJoYhsntHDyobtfokVeg3InshPGhh9zT5/Tpok99HDU9cqgP2Z/S5MnGumfPquLg0UetxYu2ApOa6lzkbNli3C7TUmQk9XHnDmKxYs77CQxUt+80Tp40F2KtWon7Dh3MV5gSE9UtR71DzmvXEN96S9w//LB7BG9ugkWTB2DRxDBMbkaOv7ZypXkdrfzwYfeNK/tg0jtozCyyX6WoKOd1Fy0Sdbt0Eddmbvi+/FKUFyrkXMBoW2NynDozkSNvCcopKEiImDlzMl5dMvvNHA5z2yi9TyirVaF166zHW7DAOPcdO+z/RnkJFk0egEUTwzC5lT17xIdv9WrzOtoWVPfu7htX/ii7K2advOqRkRH51KnmIshMaN13n7oqYyUm5PejD1Yrp4ULzT1vA4iguVaCSg4OXLOmeeBcsyDAdeuq9xMnmr8Xh4O8rmv1goPFdYMG5AX+m29EXu3atJqWX2HR5AFYNDEMkxuRA9b+8495HTmWmLu2XuTVkw0b3NOn7NFaZ5pqYPBgo6jw9TVuUcXHq3Xk7Tt9ku2XZsywrhcfr4ZGkVNICLWXV8u0YMj6tGaN8bkSEhBLlzbW1a84Wb0fs608Le3ZQ9uEcp7ZNm5+g0WTB2DRxDBMbuPff+0JF62OnZAjdhg5UvR5/Lh7+hw2TPSZ0X9mmzUzCoIhQ4z15IC+AIj3328tKOQTZA8/bF7no48Qb992LqbCw9W8N94w1vPxMV/ZkbcPrdLvv1u/l/HjRT05Nt7QoVT+++8ir3Bh89N52U1yMq1sPfVUzo3JoskDsGhiGCY3Ifv42bLFup623XX//e4Z190+mBDV0263b1vXcziM7gAAEH/7zVj31VdVgeBMiGjiQQ5erE+XLyOuWmVe1qEDtZdP4TVqhDhmjLFu167GuV6+bN6vvI334IPWW2ixsdbzjoig7b+qVUWeHHswJ5Hf3wMP5Ny4LJo8AIsmhmFyC1u2iI/Ptm3W9WS/PFm1WckOH0yIiM88I/pMSLCul5RkLia0gLkaqanqKotsHK5Psv3SlSvmdQYPpvK2bUWefFx/7lzVzQMA2UI1bmzs67PPjM8lC0YrcXfokPV7mT/fvI0mjOR/VgDIz1NOk5KiBkmeOjVnx2fR5AFYNDEMkxvYuFH9ODtDq2dl62SX7PDBhIjYq5dxtccMM4eOZsJNtt0CQOzbV72XhYxsv7Rpk7VYkd0paM+vXZ88qW7l9eihvis5rVqlzlW2RbNKzk4jpqTQCT19mypVaA4Oh7oqqBmn5xQOB23drlmjzi86OmfngciiySOwaGIYxtPIp9U0g2MrPvlEfESzQnb4YEJUV4DMfBNpnDtnFAYPP2ysJ4daAUCsWFG9r1ZNXMv2S++/b+y/RQv66E+ZYi1oZPGq9RkRYV73yBExXnIyYr16okzvuVxLzrY+Q0LM22zdSuX6lS+dT+hs58wZ49zefTdn5yDDoskDsGhiGMaTyP/HvmeP87qyjYszQZIR2eGDCRGxdWvRr9lxew2z1ZiZM4312rQR5Xr/S7IDSP2KVtOmxv7/+YfqyFtl8nwHD0asU0fcDx9OfS1YkLH4+eUXtUzvaBLAOtachpkTzWeeEat/Aweqc81pJk82zk9z8OkpWDR5ABZNDMN4ir//Fh+g/fszrq/VNTOQtou8qvXdd5nvR48sVJzZWS1davz4hoaqdeLi1HLZNxGAGidOtl8y20Lz9yeB+dtvxlUt7XriRLXs0iUSK40amQsmTbDGxKj506cjVq6s5gUH0yqUFRcvmo9x4QKJPL0NlS4qWbajd+0AgDhpUs7OwQoWTR6ARRPDMJ7gzz/FR+jAgYzrf/891fXxyfyYstjYuDHz/eiRV2isgsoiksG0/gOs/0+vfHoQgJw2atcVK6p+kmT7Jb3dEwDivHkkWMqXF3my0TuAavz94YfUl+yFXU6BgWLlR3Y54ONjLn727XP+3qZNM7b59FN6h/36qfkdO+Z8GBQzgZtR6JuchEWTB2DRxDBMTiN/jOyEPpEdF965k7kxR4wQfZw4kbk+zJBXVpx91F9+Wf34mgXcNTvKL6+K1aol7mX7JU1Qyik21uh9W942K1NGLbtxg+bTsaP5+H360FhynD8ACpMih3wBQHzpJefvzMwnVIkSlG9mi+XsJGV2kJaG2LChOofx43N2DnZg0eQBWDQxDJOTyNtEsiGxM7SAsJkNaSLbBl2/nrk+zChVyp5gkm2HABDfflstT0mh1RorwXTpknov2y/pXQ+8/TZ99OUQIwCIb75p3ve8edSPlRE2ADm/TEsjg3ktr317ytNv4WUUU2/FCmP/a9ca7aIArEOxZCd6Y3OAnDc4twuLJg/AoolhmJzi11/Fh8iux+0//hBtXMXhUA2o3eWDCVHd5rISTA6HEHxa0m8Lnj2rlsuG2p07q97RZfultDSj/6MLF9T6WpLj02mpdGnyH5WWRg4mrQTTsmVG55dHjhjnPXCg8/eVlobYpInapnt3o78ledycRnYcCoA4alTOz8EVWDR5ABZNDMPkBLKzwpMn7bWRPVm76rzw7l3Rtnhx99nDOByi36JFreuZeeHWr8LMm2ctVpYvV7eqZPsl+fQfAOJjj9G89AF75bAwclq5kvoxEyyVKonrnTtV/01jx9I4jzyittE74tRjtnqj93MkJ2fOQLMDvUE7ANmI5XZYNHkAFk0Mw2Q3P/4oPkanT9tvV6MGtZk+3bXxsssHkyyYypWzrnfzpvoBLlLEeKJO9sStT9HR1vZLchw2ADK2PnDA2IcceFhLTZrQPFJTjdt3AOqY+iP2166RvyQ5z8srY4/s+gDE48eTiJX70K7N3C5kN3o/WK+8kvNzyCwsmjwAiyaGYbIT2Uj57Fn77davF+1cQTZUHjPGtbbOkAVTtWrW9fSBbQcNUsudxVOrUcO46qHZLzkciCVLivxSpWjLq08fYz+vv27M04Ia643DzcSLnObPpznovXT36OH8fek9jgOYh2DRUkxMZn+ZzJGSYjSGz2jFLLdh9/vtDQzDMEyu57vvAF58ka7Pnwe45x577RwOgIcfpuvISPvjrVsH0LChGHvGDPttM5qP939fnvr1AcLDzevt3w9Qvbq4X7wY4KefxP3WrQClS5u3/fBDgIULAcqWpfvu3elTXrQowMmTNH58PJVNngywaxdAoUIAy5eLPoYPByhWDOCLL0Re7940/+bNAWrWBOjWzXx8RIDChcV9nToAyckAt28D+PkBRESIsgULAP7+27wfAID33gOoUEHct2lDfw8fpr9Nm4qySZNo7DJlrPtzN7t2ARQpAnDjBt0PGEBzuPfenJtDjpJDIq5AwCtNDMNkBzNniv+DDw93ra1mmOzKMe/s8sGUmir6bdbMut5ff6mrFvptyNGjrVdZ9uyxtl/SGyefOYM4dKixD9lgXkuasb3ZiTUA40qLvCplFejXma3P3buq4b2+/48+Uu9d/efCHXTrps7Brn1dboS35zwAiyaGYdzNl1+Kj9KlS661lUOM2CW7fDDJxtzt2lnX+/hj9UMsn9JLSbHe+gIg55Zm9kspKUZHlKdPm/eh99P02mvUR2Ki6thSv72mzxswgNrp7ZC05Myz99Sp1s/4zjuIQ4aI+/79s/a7ZIbLl9U59e6d83NwNyyaPACLJoZh3Mn//ic+TK56T5bths6ds9cmu3wwJSWJfrt1s67Xt6+o16qVWmYlcjQRduOGmqfZL+lXhlq1MhqAA5C40bsLuHyZ+tCHTZHTK68Y8y5etPbV9Oij1s8fH4/o7W3e7tlnjTZehw5l7XfJDLL3cgCye8sPsGjyACyaGIZxF598Ij5MERGut+/ZU4iBjMhOH0yyu4LHH7euJ4dPmTZNLfvuO2vR8u231v6X7r/fuEpj1oc+xIcWDy0hwegbSk7PP6/ez5hBAlFe7ZLTTz9ZP79ejGjpvvtoHlOmiLz27XM+DIr8O2pCNT/BoskDsGhiGMYdyNszGXmFNuPIEdE+I7LLBxOiGrKlb1/zOg6H6lhSO5mm0bKltWg5ftzcfunMGWPdF18072PcOPVe82El+8IyS1WriusSJehZ9Ufu5WRl73PunHl9Pz/Eq1eNK2hbtrjnt3EF2c0FAOLevTk/h+yGRZMHYNHEMExWee898XGKjs5cH1r7jKLYZ5cPJkTEW7dE3y+8YF5HHzctNlaU6cWCPt29a26/pDf2tkq9e6v3Tz1lnLe2ouKsn+XLSdzIefrVKTlUi4bDgdirl7UYRKRVNFmk5XQYFIeDAgtrc2jYMOdXuHIKdjnAMAyTx3jnHYApU+j6+nWA8uVd72PIEPr76KMAwcHW9Y4dE0fZx4wB2LzZ9bGsiIsD8Pen61dfBfjhB2Odw4cBSpSgax8fOspfqhTdb9xofWz+2WfpeLufH8CZM5R39y5AxYoAXl4As2aZtytSRO1jxQpxv3MnwO+/k2sFbd4a27eL6+LF1bLUVID162lsANE2IYH+dupEcqNoUbXdli3k9mDlSmM+IrlaKFwY4JVXKP/33wEuXlTdGGQ3mzbRHKOi6H7tWoAjR+gdF2hySMQVCHiliWGYzDJhgvg/+sw6Jzx/XvThbEVAdso4d27mxrJCdig5dqx5HdnDdsOGatlrr1mv6vz+u2q/pBlVm3nstpvu3DF6HbeyL9JSs2aI+/eref/3f+r97NnG5757F7FiRWN/CxaIOnp3C3fuuOd3cQXZFqxixfy7uiTD23MegEUTwzCZQT7NJW9RuYrWR0iIdR3ZB9OmTZkfy4xr10TfmjG1Htnrtuzh2yy+nJwuXlTtl+bNI4N1Hx/rNrKbgcqV1bJHHqFxv/hC5BUtqp7gM0uvv6564+7Rgwyz5Tpmp9pkX1taevNNUZ6aili7tij76iu3/Sy2CQtT5yf7uMrvsGjyACyaGIZxFTlMx82bme/nrbeoj+bNrevIqzju9MGEiBgZKfr+4ANjeVqaKmLk2GgnT1qLlGLFyJZHtl86fhxx9Wrn4qZBA+uyBQuMIVacGXFr6eWX1Xv9ahMA2UTJmDm2rF+f3oeGvHoGQOIzp5EDBxcpQqcACxIsmjwAiyaGYVxBdiQZH5/5fqKiRD/yx1imVStRx50+mBDJ6abW9yefOJ+ffoXLbAVGS2PGGA3C79yhY/gZCRyrdO4cuTTQ7suWtfbybZU+/BBxwwY1z8zD+eOPG9sePizKHQ7Ehx82X3nKKeQtXQDEiRNzfg65ARZNHoBFE8Mwdhk2zHp1wlW0ftatM5Y5HKrDRHevIFy4IPo221LatEn9KGsrXA6HcTWoUiVxvWGD0X7pwAHXVoLkVLiwcdXnzz/Ng/QCqAF95RWY+HijQ0u9UFy1yti2RQvVNujYMbXcWUiV7GLgQHUOV6/m/BxyCyyaPACLJoZh7CD7DLp9O2t9aU4wq1Uzlsk+mEqUcL9Br+wP6dtvjeV6Z5KaCwX91pg+XbtmtF/q3995G3l7SZ9GjkScPFncV6tmdBMgJ7NwKStXqp7NtbRrl3jemzfNbaz0Ylb+/Z9/3r2/iR30YVAeeyzn55DbYNHkAVg0MQyTEYMGiY9VVk9GxcaKvvSxzGRR0KlT1sYx48QJ0f+PP6plDgdi3brqhzkhgcqcOY2sU4e2F2X7Jf1KlT5NmuS8fNEi9X7NGlph0u5lT+j6MCoAiB070pwOHzaWaUb7aWlkS6YvL1xY9a6uFysHD7r/d8kIfbDjAwdyfg65ERZNHoBFE8MwzpDDbmgiIitoff3xh5ovewQfNy7r4+iRT1n9+qtaFh9vFA+anVWTJtbiZto0o/3S22+7Joj0SXZ0Wb8+GZTLNkRy0nu9BhBOJuWQNgCI99wjVu3GjDHv78sv1fcir5y1apXzx/hlQ30AWm2zsn8riLBo8gAsmhiGseKZZ8QHy8xDtKt8/z31VbSomr92rRjH3T6YEBFDQ63Fmt7mqHZtytevsAAglikjrvftU+2XunZ1LoZeew2xXz/rcvnoPgCtVsnez/VJ7xtJc5fgcJC40As5ROen7eTQN/JqIADixo3u/00yQi8+Fy/O+Tnkdlg0eQAWTQzDmCEbG7sjGK4c003e4pNPornbBxMi4p49ov+VK9Uy2f8TAOKTT1K+3umjPt26pa7CDB3qvL7elxCAKkjlU4LNm9NqypIl1v09/bR6r225mQm9zZuNp+bkpA+OrAlbADJy12+hZjdmdltZOaWZn2HR5AFYNDEMo6dnT/HBctfJNS22mbySJG9FudsHEyLijh2i/3/+Ucu6dzeuxpht08npoYdoJUe2XwoIsK5fpw7i1q1qXoUKans5/fsv9S+LKDnVqKHeT5kinmfxYmP97dudP09oqGh/9y6ir69nV3Y+/FCdnyfcGeQl7H6/czCSDcMwTMGie3eAf/6h6+RkNf5ZZlm6VMQ2e/FF+tu6NUBICF1fvw5QtmzWx5HZsgWgY0e63rRJXCcnA/j6qnV//BGgUCGAkiWt+5s7F+DJJym2mUxcnHn9zz4D2LcPoEMHkbd4MUDfvgDR0Wrdhx6iOUZGGvvXqFwZ4MIFcX/8OEC9enTdowfA6tWirFQpgPh4gHbtzPuqVw/g6FEx1t9/A/TqJcpv3zbGrMtOzGIWnj4NUKtWzs0hX5NDIq5AwCtNDMNodOwo/i/fXdHp5VAjsbHZ74MJUY1Tt2OHyD93zrjasnYtor+/Mb9oUXUVTF61Kl3a+QqO3ut2o0bW3sD37qW5mRl1WyVtO85sZUy2uzJ7FtmmKzWVjM21ss8/d/9vkREff6zOtW3b7Dc4v3yZ7Mv27cvecbIbXmliGIbxEO3aAezYQdcpKe6LTl+nDv39+GOAokXF6kaJErQa4u4I9KtWAfTsSde7dwM8+CBdL1tGK0Uyc+bQypoZiYn0NykJYNo0gHffFWWxsdbjf/stQLNm4j4kBGDBAoBHH1Xr9ewJsGIFXTdoQCtHGk2aABw6ZN6/9tts3w7Qvr2x/MYN62e5dYveOwDArl0ArVqJOtHRxtWe7CQ2FqBMGTVv7VqAbt2yb8zwcIDatekdAtDqmvxb5VtySMQVCHiliWGYFi3E/+mnprqv3/XrRb/Z7YMJEXHpUnN7HTOv23qfTPr0/PO04nHvvfZWf6pVQwwKUleXrAL6asFxw8ONZWZOKgHEqT5ENfafVWrWTFy/+65o63CoTjXHj8+e38IZn39unK873FlYcfq0cTzZwWdehQ3BPQCLJoYp2Nx/v/iQuNMHTlqa6HfLFnGdHT6YEFX/R2FhYg7Fi9vf9tLS0qVG/0vO0mOPqfdr1iCePWus9+yzYr7vvquWLVxo3f+AAdTGSoTJSf49AdRQJ7JzTwDarsxJbt40zvfTT7NvPH3YF72YzuuwaPIALJoYpuDSqFH2CCZE4alaPh4/b557x9D46Scxhubc0ZmPI2fp0iXVfimjVKqUuC5ShFbqfv7ZWE+bV2oqop+fyK9bF/HUKbXuPfeIa83OSC94zNLw4eK6Rw/1HclxA595Jnt+B2eYBTm+dCl7xjp40DjWkSPZM5YnYdHkAVg0MUzBRDYAdrdg2rXL+NHavNm9Y2h8+60Y48wZypNXtuwmf38SNPoVILvp//6Pxu7WTc1/4QUxV72Y2rEDcepUNW/CBHG9Zg21+/pr52OPGKHeb9smxtQH/M3plZa4OON8n3gie8bau9c41smT2TNWboBFkwdg0cQwBQ/ZTsfdJ5Ucjpz7cH31lRjjwgXKe+891wXPuHHm9kuFC9trf/gwBTHW5589S3NKSBB+qgBIsN65o/pF6tFDXQ06epTmpPcUrk/z5onrsmVVZ5SyIHvggZwPg/Ldd8b5/vuv+8fRrwx6e+f81qMn4NNzDMMw2Uz16gAXL9K1w+H+02u9e6v3MTHGU1Lu4NNPAd54g64vXwYICgIIDib/Q66waRNA06bm/pFSU5239fKi03WhoeJUGgDAa68BfPMNXX/1FcDo0aLszz8Bzp5V/SDt2gUwfDid/AMgv0VxcdY+mwAAfv4ZYOpUgKFD6X7ePIAhQ+g6Lo58NWmsXw/QpYvzZ3Ent28D+PureWXLkh8qd/j90ti8GaBTJ3FfvDjAiRMAVaq4b4x8QQ6JuAIBrzQxTMEhMDD7VpgQjeFCssMHEyLiBx+IMSIjKaxJZrbUrl/P2H7JarVpwgSaywsvqPnh4ZSv3xYDMLdL0m9fJSQIezCz1KAB4u7dxufQkP09lS+f82FQZPsyLbk7nuCaNWr/5cvTPwcFDbvfbyfam2EYhjGjbFmAqCi6zo4VpsREgEaN6Lp4cRrDx8e9YwAATJ5MCYB8C0VHi1WN2rXt9VG/Ps3v668B2rYV+Y0bq/V69DBfbdq3D+C992jV5McfKW/wYPqEV6tGqz+VK4v6w4eTjyjNgzcAQOnStCIUEED3QUEA48cDFCsGsGeP+bz37CG/Uy1a0P2oUTRm2bK04lWiBMALL1DZwoX0bty5suOMhATyqj54sJp/7ZrwAu8K+/cLf0oaf/1F/9w+8gjdV6tG/UdHAwQGZmraBYMcEnEFAl5pYpj8T4kS2bvCJPtgKlfO/f1rjBsnxomJQZwzR12BsbO69PHH9A6qVXNez8o/U2Ii4q+/qnma/Yx+BQjAGBQYgLxRnz8v7vVuAvRp6FBaSZHzjh0T70XvbfzWrez7Dcz45RfjnF9+2fV+kpLIvYJ+hUofvLhuXXIJUdBhQ3APwKKJYfI3Pj70ofH2zp7+jxxRP2jZZWz82mtijJs3ER991LWtOAAKb6L3v9SmjXr/6afmbUeNoo+6HKakYUOaW3KyuWirWNGYN2eOay4NIiJUg/cWLcQ7TktDDA4WZf/7X/a8eyvu3lXdJ2jp4EHX+rl4EbFqVbWPvn1JNMl5991HoWMYgkWTB2DRxDD5Fy8v+tj4+mZP/3rbkt27s2ecIUPEGDExroslADrdtnKlmte2rXpvtmICgLhzJ+KyZWqe5nPKzCnlww9b92M3xtycOSRKChUSeatXi3eiX9W6ejV73r0V+tUfAMR69VxzX6H/50d7bnkFEQCxdWv6/RgVFk0egEUTw+Q/5GP//v7ZM8Y336gftgceyJ5xnntOjHH0qLiWxYSz1Lkz9SOHDpEN4gEQR4+mD75Z+5gYxIAANe/SJXviTV5piow0D+eiT6VK0RagHHQYQIQZcTgQe/US+WPGZM97tyIx0fg+ABB/+81ee4cDcdIkY/t9+xC/+ML42929m62Pk6dh0eQBWDQxTP5CFkxly2bPGK++avzoudtBJiJinz6i/8WL7Ykk/WrQnTtq3vPPq/dy+BU5vfiicRUpIICe8623jPW9vcW1HINOE15Fi2Y83++/p99P3jKUt9xOnlTra848cwr9apuW7Hw+YmONW6Ft2tB26bRpan7Pntl38jI/waLJA7BoYpj8gyyYKlXKnjFatjR+NNetc/84smftF190XTCdOmXcbqtUSVy3bYtYpYp52zVrjK4G3nzTPJaZPv3xh7hu3FhdFQJQjdn1wkMviq5cEe9D9vqdXR61rUhKMrfPeuutjNvu329sN2kSic/Jk9X8p59GTEnJ/ufJL7Bo8gAsmhgmfyALpmrVsrd/AMSPPsq+sdq1E+NkJuBuQoJqWCzHcgNAnDjRuq3ZabctWxA7dXI+Zt++FL5Eu2/eXC3386MtTH27Bg3omWUx9fzz4l3oT83t2+f+9+0MvR2YLEqdIYe3kcWow0EhZ+T8QYMohA3jGiyaPACLJobJ+8iCplYt9/d/967ov2RJ9QSau50nNmvmukjS0oABiHv2qHm1aonrIkWs2z71lHn+b79lPG54uPP4cF26mOdPnWo8zbdnj3gXH38s8u+7L3u2QK1ITjaeaAOgFTqrE5KJiSQe5fpVq9L7cTjUE5AAFDYmJ58pv8GiyQOwaGKYvE1amvgI1a/v/v5lH0xdulCedv/HH+4dy66vJTMj8OXLVRsofWrf3rrMzEarWTN1lUs+2q+lGTNo3k8/bd23bMgup5071QC+NWuK1Zb4eLXu2rXufc8ZYXaqzdk8zp83bt8NGEDbemlpRq/pY8bkfBy8/AiLJg/Aoolh8i6yYGrUyP39yz6Yxo+nPM13TtGi7h3Lytmk1ak2OYWE2BNbdpMz8QVAvpru3KEPv97AW56vldPK6Gj1BN+iReI9zJ8v8kuXzlmD6JQU6wDB2uk9GbOtO80VQ0qKcdVp0iQWS+6ERZMHYNHEMHmT1FR1VcTdyKsNP/xAefJJtDt33DdWuXLmH+oePZyLl9KlyUDbqlxekdJ8VmlJXtXSl2npjTeMeevX05z1ceTKl0ccO9b5fKtXR/z3XzVP+09vUpJ6lH/BAve9XzusX28+508+UeulpRltkgCEQ8vkZMTHHlPLPvggZ5+loMCiyQOwaGKYvIcsmFq2dH//sg+mzZtFvraq4s4ArGYepRs3puRMgIwaZX/lyNVUq5bRxql3b1oliY83roqdO6ee9jNLEybQqTd51UVj7Vq1bk56vU5NJc/mZnO+dEnUi4kxGrJ36EDe2RHJnkn/Dj77LOeeoyDCoskDsGhimLxFSor4KLVr5/7+Zfse+YTU77+LfHegP42npTVrVJ9HZqLK6ti+mfiyKitd2jxf71QSgPwhpaSoDjIByA2Aw2F+wk/eftPHqtP8K6WlITZpIvL1qzrZzZYt5u+gTx9RR29YD4D43ntim+3OHfW0IwDizJk5+xwFFRZNHoBFE8PkHWTB1KmT+/uXfTDFxIj8pCSRHxub9XHMBFOxYhRoNiMhZMdJJIDRB5CcOnc25vXrZxQ3H31Ecx0zxlh/40b1VKFVkt0bdO0qxMbevWq9yMisv1e7pKXRaTyz+f77L9UxOw2obU0i0m+lP+mo2TMxOUOeEE2zZs3CRo0aob+/P/r7+2PLli1xtRQQyOFw4JQpU7BSpUpYtGhR7NChAx45ckTpIzExEUeMGIFly5bFYsWKYa9evfCSvA6KiDdu3MD+/ftjyZIlsWTJkti/f3+M1f3XKjw8HHv27InFihXDsmXL4siRIzHJRatBFk0MkzdIThYfp27d3Nu3XsTo/zOibUd9/LH7xwJAfP99CkzrTHzUqGFPLPXtazRA1pLsfkBOFy+qvpyKFCFRYOazCQDxwgWj/yR9KllSvZe3OWVD85Ejs/5OXWH7dvP5lilD24JPPqnm33OPuk0XG2s85bhwYc4+A0PkCdG0YsUKXLVqFZ48eRJPnjyJEydOxCJFiqQLo+nTp6O/vz8uXboUw8LC8Nlnn8VKlSphvLRJPWzYMKxcuTKuX78eQ0NDsWPHjtikSRNMlbx7de/eHYODg3Hnzp24c+dODA4Oxp49e6aXp6amYnBwMHbs2BFDQ0Nx/fr1GBQUhCNGjHDpeVg0MUzuR17pkf4z4BYSEkTfpUoZTzetWyfKs4p82k9Lly6pp7B8fY11Kle2J5hOnjR68tbSDz8Y8/73P9UhJQC5AVi1ynqMhARzL9eyLyZ5G69ECSFCT59W22TkINKdOByIrVqJscuXF9cffkiiSZ7b0KGqD67r18ktglxn6dKcmz9jJE+IJjNKly6N33//PTocDgwMDMTp06enlyUmJmJAQADOmTMHERFv3ryJRYoUwcWLF6fXuXLlCnp7e+Pa/5xgHDt2DAEAd+3alV4nJCQEAQBPnDiBiIirV69Gb29vvCL52V+0aBH6+vq6JIBYNDFM7iYxUXykZFsTdxAVJfru2tVYLoucrG4fycJPFmjDhok8M/slO2n8ePqom5U1bYo4e7aaV6IEnVqTV55KljRumbVuLa6rVbMONiufFqteXVzPni2e//XX1fo5ya5d9t/lzz+rbaOijD6YVq3K2fkz5uQ50ZSamoqLFi1CHx8fPHr0KJ49exYBAENDQ5V6vXv3xoEDByIi4saNGxEA8MaNG0qdxo0b4zvvvIOIiPPmzcOAgADDeAEBAfjDf2d/J0+ejI0bN1bKb9y4gQCAmzZtspxzYmIixsXFpadLly6xaGKYXIpsM/PMM+7tOyxM9P3GG+Z1tFAgVuV22bpV/ei+9hoJMv3qRmZSVBTi7t3mZdu3G213Vq82evl++231vlIlxE2bxP3LL9N2ndkqln4bTkvR0fTssnNQAJprTuFwID70kBjbyjC+SBH650HmyhXVBQKAatPEeB67oskbPExYWBiUKFECfH19YdiwYbB8+XJo0KABREVFAQBAxYoVlfoVK1ZML4uKigIfHx8oXbq00zoVKlQwjFuhQgWljn6c0qVLg4+PT3odM6ZNmwYBAQHpqWrVqi4+PcMwOcHduwB+fnTdrx/AkiXu63vtWoBGjej6hx8APv7YWGfXLoB9++jarNwOiAAdOwJ06KCOPXEiQKFCADduZK5fAIAZM6j/X34BaNFCLWvbFiAmBqBdO4ADByivQweA69cBHn0U4JlnRN2qVQE+/FDcnz8PMHUqQKdOdP/TTwD33APg7w+QmirqPfAA/Y2PV8d+5RWaV/nyAP/7H4D2n+nGjQHS0gAefDDzz+wK+/YBeHsDbNki8g4fVus8/DDNPzkZIDiY8sLDAXx8ACpXBoiLo7xt2+iZunTJkakzbqawpydQt25dOHjwINy8eROWLl0KgwYNgq1bt6aXe3l5KfUR0ZCnR1/HrH5m6uiZMGECjB07Nv0+Pj6ehRPD5DISEgCKF6frwYMBfvzRfX1/8w3AyJF0vXkzwEMPGesgArRqRdfnz2dunKNHxYdY48oVgJ076YOcEeXLA1y7Zl4WH08ipk0b6k9m9256rrJlRd7x4wDz5wOUKyfySpcGiI0FuHRJtHvwQYCXXwaYO5fy/voL4LHHjOP/3/8BfPqpMf/wYRKjt24BlCwp8tesAejePeNndgeINNa6dXR/331COGp89BHAhAkA8qfizBmA2rXVert2GQUpk/fwuGjy8fGBWrVqAQBA8+bNYe/evfDll1/Cm2++CQC0ClSpUqX0+tHR0emrQoGBgZCcnAyxsbHKalN0dDS0bt06vc7Vq1cN4167dk3pZ/fu3Up5bGwspKSkGFagZHx9fcHX1zczj80wTA5w5w5AiRJ0/eKL4gPuDoYPB5gzh65PnTJ+JDV69qS/Q4YA1Kjh+jiDBpFIkUlJoRWe5cszbu/tbS6YFi0C6NuXVmz0/2/YtSvA778DlCpFwgGAxMOMGQD16xv7io2lv8uWAfTpQ22qVgW4fJnye/QwF0yvvmoUTE2aAISG0rwXLgTo35/y/f3pOXLqP7kHD5JIkpEFk5lIPn4coEEDNS801NgPk4fJga1Cl+jUqRMOGjQo3RD8Y+lcblJSkqkh+JIlS9LrREREmBqC75Y2v3ft2oUARkPwiIiI9DqLFy9mQ3CGycPIfoqGDXNv3w8+KPqWfTDpkW2dXCU83GgvU6MG4u3b9uyT9DY0WqpYUZxAO3fOWH7gAOLUqWrezp3Og/RqwXYR1ROEVqlUKdXIW0t//UV9JCUhli0r8n/6yfX3l1kcDsRevaznfvKksc2hQ8Z6Ou84TC4nTxiCT5gwAbdt24bnz5/Hw4cP48SJE9Hb2xvXrVuHiORyICAgAJctW4ZhYWH43HPPmbocqFKlCm7YsAFDQ0OxU6dOpi4HGjdujCEhIRgSEoKNGjUydTnQuXNnDA0NxQ0bNmCVKlXY5QDD5FHi4sTHy8V/jZ2SkQ8mPVq9o0ddG2fCBONHuGNH44k0q1Shgnn+33+LMWbOVMv69EE8e9bY5o8/rMcZPlx1q3DhgmoQbdbGLNYagIi/J7tlABDx5HICWeTqk5kBv9nv8d//izN5jDwhmoYMGYLVq1dHHx8fLF++PHbu3DldMCEK55aBgYHo6+uL7du3xzDdsYS7d+/iiBEjsEyZMujn54c9e/bEixcvKnViYmKwX79+6U40+/XrZ+rcskePHujn54dlypTBESNGYGJiokvPw6KJYTzPzZviAzZmjPv6zcgHk55Bg6iuK76grl0z/2APGID47rv2BJNZCgykE3YacrgRbVVEjuUGQE4t5RAsegEn+x1CRNywIeN5zJtnzJs2jdqnpalesadOtf/e3IHswT2j1aUdO9RyLy9atWPyLnlCNOU3WDQxjGeJjVVXNNxFRj6Y9MjbXhmJK40vvzT/YI8dqzpPtEpWXr7lcBz6UCWdOhldGAAgPv+8eV9BQSKorMwnnxjr9uih3n/wgbGO9v+3egeXkqVEtpKaivjcc+rYsiuEtm3V32/zZrVu8eLiGZi8DYsmD8CiiWE8R0yM+JhNnOi+fu34YNKj1bfjR8iZjZJZnDZXkrblhYj43XdqWUiIfe/gALT1ZoZeHFWpQmJDu+/Vy+jf6amnRPunnxb5w4fbe79ZJSoKsWFDdU4VK6pbimvWiPpr1qh1y5XLOWHH5AwsmjwAiyaG8QzyttZ/fm3dgvyx/PFHe23Gj6f6Dz6YcV05qK3e2aN+BcQsVa1qnv/ss2KMtDTVxsnX1yigtHyzvmbNMp+7WRiXrVspWLB2//PPxjohIdRebz+VE7ZA+jAvWtK/j4QEqv/XX8b3rTnaZPIXLJo8AIsmhsl5oqPFR+39993XrxyZfssWe23kwLOyDZGepCRardDqNm2qfpz1QVxdSVu3inH0dkZyHDc76dYt8/nL7xyAVovklT4Ao0F35cqIKSnUftw4kd+jh/0tzMzgcFBwZLPn69ED8eGHxb12WHvJErVe3bqIusATTD6DRZMHYNHEMDmLbGvkTsNhOYbb6dP222ltnIXI0IsJV5OzcCmayElNRbznHrWsWzdxbRWIV0svvWQ9/48+UuteuEDhVLR7X1/Er75S68yfT231YksKCep2bt92LhLlwMYAZJukXxlr2jRnT+8xnoNFkwdg0cQwOUdEhPi4ffKJ+/qVfTC5srowbRq1qVHDvDwtTV1ReuMN6w968eKuCan/wnEiIuLatVkTZTt2mM9fL3gef5zyX3hB5LVqpZ6AAyDjfETy5aTlNWzofCUuKxw7ZtxqDA4W1126qCcRH3sM8dtv1fqtWpHoYgoOLJo8AIsmhskZLl8WHzjZsWJW0Ptg0h+pd8aNG87b7dmj9v3jj9aixc/PmGd19B8AceNGGiM5GbFaNet6zo7Ua0mz5dEzapRab906Gk/O04vAUaOorexkFED1FeVOFi40Po/eF5X+pKD+uTp3phOGTMGDRZMHYNHEMNnPxYviI/fVV+7pU/bBVKaM6zY2WtulS9V8hwOxd2/1Iz1iRNZWguSk+fnVGyzr04svGvNKlhTXo0ebP9fBg8Z2ly+T0bacp62yaUkz6l60SBWDLrq+y5CUFMSXX1bHDghAPHVKFUTt2yP++ae4L1pUbdOzZ8aOSpn8DYsmD8CiiWGyFzm0yMyZ7ulTtovq1s319trJq2LF1PyTJ9UP88mTiKVLu0cs9e1LYyQmqgbl+vTOO+ppNi3JNk179xqfKTUVsXlzY7vERNVAHgCxe3dxXaMGCcXkZDrCr+XLvqLcQUQEYu3a6jwee4xcLMiiGgDx33+NhvZaevppYZzOFGxYNHkAFk0Mk32cPy8+dt9+654+Dx8Wfdr1wSRz545oL29tDR8u8p94AvH6dWthI/spspP++YfGWLzYeb1du4x5+i0ss5Wf3383tqtfn8SQ3reRnD7/nNpv3KjmmznDzCybNhnH/eILUS6HaGnRwjosyqBBJAwZRoNFkwdg0cQw2YPs0+f7793T56pVok+7Ppj0aNs82krKlSvqx3n/fjXkRseOarlVHDardPMmiTP99pKcfvsNsV49Ne+nnxDfekvcT5pkfBbZm7qcXn8d8epV5/O6coVEVYsWIu+DDzL7y6g4HObexHfuFHX0733bNsSRI41thg3LPgN0Jm/DoskDsGhiGPdz+nTWxY0eOWSJXR9MeuQVGUTyEaXdP/ggfezl4/mjR6sf8GeftS+WnniCxjBzFqmlpk0RJ09W89q1o9UkOe/QIeOzvP22eZ+LFqm2QADq1l7JkvScetuny5cz905l4uPJMFvu9777yJGpzMSJorxJE+MpPwDyrJ6dvqCYvA+LJg/Aoolh3ItsF7RggXv6fOUV0acrPphkkpJEHxcuqB/oDRuojhw6RD5ZVreuvVhyWlq1yngCTZ8++8yYFx5OYVy0+2LFjPY7x4+rbdq3V8WVs63DV1+lPmTP5c78O9klLAyxUCF1rHHjjCtEsi0aAPnG0p8QnDiRxRJjDxZNHoBFE8O4j2PH1BUPdyAbN2fFw7N2tP+pp0R/lSqRAbQ+ltxjj1mvNmWUbtxAnDPHutzMxigwkISCfErvo4/U+aelUbBerbxVK8RSpdSVImfzWrdOtTEDIAGWFX76yTjO8uXmdd97T9SpV089oQhAYo9hXIFFkwdg0cQw7uHIEfEB/O23rPenj5Pmig8mPWYevZcsoTLZ8LhFC9X2yMwuxyr17En2S64ILG0M2TjdTMzItlwARoPxnTudjxEZqa6cdeuW+dWc5GTVOSYAnQY8c8a8vn7rTe9IE4A9eDOZw+73uzAwDMPkIg4fBmjShK6XLQPo0ydr/d29C1CsGF2XKQNw/TqAl1fm+nI4ALp2VfPu3KH+f/gBYOhQypswAWDaNFGnRw+AyZPtjfHXXwDnzgGUKuXa3PbupWctXpzuK1QAiIgAKFSI7m/fBihfHiAxke7HjgUYPhygdm2679oVoHlzgNatzfv38wO4cAGgYkWR9++/1vWdceUKQLt2AOfPi7ynnwaYPx+gaFHzNtOmAUycSNdFi9Jz7N8vyt94A+Djj12fC8O4RA6JuAIBrzQxTNY4cECsGPz1V9b7y6oPJpmUFEQfH9HfN9+IsscfF/nvvKOufDiL86b323TqlOurSwC0JThkiLjXe0mfPl2tf/26Gi/uww8RS5Sw7v/ll1Xj+bp1M3dkf/16Y9/yezTDmbsGLZ086fpcGEaGt+c8AIsmhsk8+/aJj6A7Qm3IPpjefDNrfW3Zon6kY2IoXx9KRDakdpb0QqpLFwo4rN2bhVIxS926GY3E5a2tc+fUMs2YXrYJMrMlkpPs1TszYtbhQJwyxdjvnj0Zt/30U+dza9OGDb0Z98CiyQOwaGKYzCGf8lqzJuv9yXY7P/2U+X4cDjq2L3+oL1ygMtk7uSun4WTXBACIP/yg3uuDzVqln39WV27uuUecMHM4yE2BVtaggbDjeughkS8LNbM0a5a4LlLEtbhsN28iduig9teihRCczpBj+cmpSBFxvXq1Sz8lwziFRZMHYNHEMK4TEiI+hOvWZb0/eRtp69bM92MWd+3FF6lsxQqRZ9ej9z33II4dq+aNGSOuy5Z13l4+hn/2rOrnafZsMW+912xtRSc1Vc03C5Mip6Agcf3dd/bfm7zFqqU337TvVPLDD43tZX9XANaBhRkms7Bo8gAsmhjGNWRv2Zs2Zb0/d/hgQqTYblo/ffqIa0TV07S8muMsbdyoxmJr0sReO7N07Zp6Hx5O87p7F7FCBZEv+0yS7YLkeZgl2RUBgH3XDN9/b+zLlW1Wvc8oTUR36ybup0+33x/DuAKLJg/Aoolh7LNtm/gYZtYrt4w7fDDpbYBkX1FHjqirQXa20Tp2NBoyywFunQXbBVAdRw4fTiJEu2/cWNjzzJyptouIEM8UGiryu3RxPl6dOuL63Xczfl9JSYgDBqh9VKpEPpzscuECore32sf69UY/UBcvuvJLMoxrsGjyACyaGMYemzeLj+G2bVnry10+mMaNU4WNw0GBXfVCx246eFA9oeZKKlYMsUcPdcVFvtfstPQx1+bMUZ9pwQJR1rq1/fEvXXL+rsLDEStXVts8/7x5AGAr5PA4WtLi1cmG6o89Zr9PhsksLJo8AIsmhsmYDRvEB/Hff7PWV0KC6Kts2cydpNIHo9UCwepXnQDU1SwvL3PBocWJk1eJSpYU1/7+zgWLPtabHEoGgIQSIuLgwSKvShWjYHn1VdfF2tChzt+VmQj89lvX3rfZNpyPD/2Wem/q27e71jfDZBYWTR6ARRPDOOeff8QHcdeurPUVGSn6euSRzPUhx2xr2FA1VtZ/2OvWzVh0HDlCwq14cXsiRd7ia9FCNaKuV08NCty2LfWt9+CtN3Z3OBBr1XJdMB09av6OHA41KK6W9u937V0fOmQ+7vz5VP7XXyKvVKmseW1nGFdhj+AMw+Qq1qwBePRRut67l7xPZxbZa/hbb6net+1w6xZAyZLiftUqMTcAgP/7P2Obkyed95maCnDpEoC3t7HMy4vkgJ6kJPq7ezfA9u0A991H9x9/TO/r6afpfskS8oxerx7AqVOU98wzAIsXq97NExPJc7crdO4MsH690Ut6bCx5Mg8JEXnt2gGsWOGat/J9+wAeeMC87PZt8qberBlAaCjlffstwMsvu/QIDJNz5JCIKxDwShPDmCMf0Q8NzVpfsjF0ZnwwzZ8v2gcEkDGzzNmzrq3QlCtH7eRVK7upcGFyBVC/vsjTe82OjiafTHKe5itK5uJFtV8745ttf8lORrU0ebLrW5///ms97rx5VEc2tNeelWE8AW/PeQAWTQxjZPly8VE8eDBrfX3xhfW2VEYkJqq2RT//bKwjBwrWhzgxS927U7uGDV0XTM88YzxZN2+euO7a1Rig9n//M3822bDeTrr3XmMYlNmzjfXWrnXtHZvNRX/K8NYtqvf66yJvyBDXx2EYd8KiyQOwaGIYlT/+EB/GsLCs9fXSS6IvV30w6Q2Y4+ONdfSeuTNK48YhxsW5LpYAEH/8UV1R6tkTsVkzcf/nn4ijRon7kiXJSNqMzz93bexly0TbxETVSSYAYvXqmTvev3at2k/ZsnQKULvXTvbpvX0fOOD6WAzjblg0eQAWTQwjWLxYfBitjIztcv/9oi9XfDClpamrQJ9+al7PrpNKWQAsW5Y5wXToEOKIEeL+q6/Uctl/VUarPXKg4IySl5fwpH3unNHJ5aBBxq1KO8gG3ACIVauqK2YAJC4RVRcItWplLugvw2QHLJo8AIsmhiEWLhQfx+PHM99PVnwwyeFZAMi1gB59wF07ac0a2jqzKq9Wzbrs+nXVkeO0aeK6Tx/VpYHmK8rqvchx2OQUHGzM08KsyLZlWvrxR5d/FkREXLJE7adOHcSoKNUB6FdfUd3UVPW9LF6cuTEZJrvIltNzy5Ytg+vXr9uuX6FCBXj88cddGYJhmDzO/PkAgwbR9alTALVrZ66fu3fpZBUAQNmyANeuGU94mYEI8MgjAP/8Q/fjxgF89pmx3qVLANWq0bW3N4DDkXHfO3cCtG7tvM7Fi8a88uUBdu0CKFeO7n18AKpXB5gwge4nTQL46CNR39l7i48HCAgwLytTBuDIETXv2jWATz5R352XF8DBgwCNGzt/FjMWLAAYOFDcN2kCsG0bwObNAIGBIj82lk7Z6U/P3bxpPX+Gye2YHI615sMPP4SiRYuCr6+vrTR16tTsmjfDMLmQH38UgunMmcwLpqgoIZgefRTg+nV7gun4cRJAmmA6d85cMP39txBMAPYE02+/WQumUaOs273yCsCMGQD33kv3gwcDJCcDnD4t6miCacoUEn1W7+34cXPB0bcv/b1xQ+SNHUtipXx5gE8/pbyOHQHi4uh5XRVM331Hv4EmmFq1IpcBe/eSKwTt/48/+4yeoVQpgAEDhGB64w3KZ8HE5GlcWb5q2rSpS8tdzZs3d6l+Xoe355iCzNy5Yvvl3LnM9yM7QZwwwX67F18U7fr2ta4nG1jbTU8/bZ5frJgx9lq/fuJ60SJyvKndv/aauG7USG1386bz55NPIcpJ76LALH3wQea8pSOqJxYBEDt3puDAiKr7BwDEmBjKlx2PApBXc4bJzWSLTdN9993n0iQeeOABl+rndVg0MQUV+bi6mQ8hu8gfYc1TdEZcuqR+oK3cGjgcqr1NVpM+3EnDhogdOoh7vb+jwEDzfpYvz/gZ33rL2O6ee+hZnc1xwwa7b97I9OlqXz16CEPxlBTEmjVF2bRpot0334j8Vq0yL9YYJidhj+AMw+QIM2cCjBhB1xcvAlStmrl+vvwS4PXX6XrbNvI+nRHvvAPwwQd03bYttTPbxrtxg+yiXKFECdp+0tOpE21Fyeaaelun7duFx/O6dcmbeFSU2k/r1jTfQoWcz+PBB2kLTGbJErJtatrUWP/eewG2bgWoXNl5v2YgArz3HiWNp58G+PVXgML/fS3++Qege3dRHh1NW4DJybT1lphI+Xov6wyTL3BFifFKk3N4pYkpaMhbN5cuZb4f2QfTmTMZ14+JUVdBtmyxruvMM7Wrae9e1dv2gw+qK1333IM4daq479nTvJ/DhzN+RquTfXFxqgsGLb30UubjtTkciP/3f2p/AweqLgFSU9X4e++/L8r0Di011wYMk1fIlpUmRIRt27bZrouImZBxDMPkBf73P4Dx4+n6yhWAoKDM9SPHHdNOXDlj1iyA116j6xo1yKC6sMV/yT7+mGLTZZU33qB5yafANm+meHPaytrrr5OB+cSJdF+8ON3LjB1L7y0jrl5VT6IBALz5JkDDhkZD6gULAPr3d+VpBIgAo0cDfP21yHvlFXrHcgy9TZsoRp1GVBRAxYp0/eijFCcPgGIAuuN9M0xuxSXRNGTIEFij/dthg8GDB7s6H4Zh8gCyGImMNH7g7eBwqFtTyckARYpY109IICGisWwZBbG1wmxbKzPs30/CTiYpiQTCu+/S/U8/0ak4mTt31Pvr1+1tEe7eDdCypZo3eDC9c5nPPiN3CpnB4aCguPPmibwxY0jQydubaWkURDgsjO4nTQL48EO6vnABoGZNUTcrW7MMk2dwZfkqJSUFk5KSbKeUlJTMr5XlQXh7jikIfPih2IYxcxhph4QE0Uf58hkbC//2m6jv7e18++fOHfdsxS1YYPS4PXYsjSGHPJHDr8iBd+V+7CKfQARA9PMzn1tmt0JTUhCff17ta9Ik8/e/data78oVUfbBByK/d+/MzYVhchPZsj334IMPQqmM1s6FGIOEhATYvXu360qOYZhcyXvvidWVa9eEs0ZXiIoCqFSJrnv0MG5hyaSk0BZcRATdf/strZBYcfw4QIMG5mUlS5LxdEbcey9tT3Xrpubv3QsQHKyuxAwdCjBkCF17edH4Gg0akANJZ6tnMn37koG3zN27xnqpqRkbj+tJSQF45hmAP/8Uee+/DzB5srGuw0ErXdoq3RtviFWuO3fIQF7DrsE+w+QbXFFi7KfJObzSxORn3n5brC5cv565PlzxwbRhg7rSkVHMuZ9+yvrq0vr15m4J7t4l31PavRzPzizt2WP/nTgciCVKZDy3OnXs96mRmIjYrZvaz2efWdffuVOtKwfulUOwBARk3uicYXIjdr/fLnkE97LjkjcL9RmGyZ289ZawZcnM8X0AWlFq0oSu588HsAoYgEj2SF260P3771Ne6dLWfT/zjNGmCIDscexQpQq5PHj4YYCYGJH/2ms09saNAPfcQ3mvvgpw9Chd61eRXnqJ6ssG486IjiaDa9m1QY0axnpDh5LbArskJAB06ABQtKjwjv7NNzQ3MzsoRFox0twmjB5NeVWr0t/mzQF696ayOXMoFIrdFTSGyVe4osTY5YBzeKWJyY+MGydWGGJjM9fH55+LPrZts663f7+1HY0ZKSnWKzPyvJ2lyZPN83fsoDHeeEO1abLqJyLC/vs4ccJor/TEE4gdOxr7/fln+/3euoX4wANq+++/d95m9261/vnzouzYMbUsszZsDJPbYY/gHoBFE5PfGD1afDAz+4+1HN7EmQ+mJ58U9YYPz7hfvSdwLTVrRv6T7AimHj3M82/fpm2zevVEXtu25nVnzrT/LpYsMe9D3raUkx1/TogUgkW/ZbhwofM2Dgdip07W7/z110XZkCH2n5Fh8iLsEZxhmCwxYgR5+wYgA2p/f9f7uP9+gAMH6NrKB5M+sO/JkwB16jjvd/VqMiLX888/RgNuZ6xapd4PHkxBhxMSVD9FAAA7dqj3JUvS9pqvr/Mx0tJou0t7lzJdugBUry62LWViYgDKlHHe940btBV47pzI++MPgCefdN4uNFR1o3D2rNh+vHlT3QoNDbW/zckw+R2XRFPZsmWhtVWYbxPKZeZoDcMwHmfYMDqpBgBw65Z6YsoOdn0wjR4N8NVXdN27N53uysgUUp6bRq1aJEBkweTnZ376rGhREeqjVCkSCQBkt9SpE8CpUxT6BACgcWOAw4eNfdhxKHn1KkDHjuqJOpmZM4WTTj0Z+ayKjqYQKpGRIm/lSoCePZ3PCZHEpuZub+hQgO+/F+ULF4rnqlUL4MQJ10/qMUx+xiXR1Lx5c7hw4YLt+rVq1XJ1PgzDeJihQwF++IGu79wBKFbMtfayE8ry5Uk86IWQ7HYAAGDPnoyNpxFpdUcfD+7NN+lI/Jkzar6ZYAIQgglACKa4OOr7jz8o1hoAecDeuFFtW7QoiUgrD+QAdAy/Qwc1z9ubhKTG//2fEEyyiKtUSbhXMCMiglwZxMWJvPXrhdG8Mw4fVle0Tp0SK3xpabTSdPEi3S9aRC4QGIbR4cqe33333Yfh4eF44cIFW4ltmhgmbzFwoLBjuXPH9faRkaq9kBnTpok699+PmJaWcb+XLxvtfYoXt2e3pE8DBojrp58WY4wYIfIrVDC2e+cd6/k5HIjTpxvbfPmlei/HrdMneS56LlxA9PFR6zszqNfPTXbS2b+/Wr5vn9rvzZv2+mWY/ES2GIKznybnsGhi8jLPPSc+nJkJuHrwoGg/aZKx/OZN9eP8zz/2+n333cyJI30qX141EF+9mvp3OBArV3be9uxZ87ndumX0g9SkCZ0y05+Eq11bnYtc9vHH5v2fOWOcS0iIvfeGiHjkiNr22DG1XBbJ48fb75dh8hvZYgjOfpoYJn/y9NO0NQVA21pFi7rW/u+/AXr1omsze58ffqBtPwDyIn7lCoCPj/M+HQ7aMtPHcMsMS5eScfS1a3R/4wYZO9+6RWNYUasWGabrjcKPHSMj96QkkTd6NMVuO39eBLPV8PKiwMIAAAMHkp8qjRUrxLvTOHECoH59Nc9Vg2zZw/jTTwP89pso0wcEPnFC2HExDGONS84tGYbJfzz+uBBMiYmuC6YvvhAf/e3bVcGUmEgG2Zpg+vVXEi4ZCaa//yYD5KwKpieeILGgnSZ75BFaVyldGuDIESGYKlQwtv32WxI6smBauJAEUMOGQjD98Qf1+cUXAG+/rZ4E1ECkvy1aqILp8GFVMB0+TP3LgiksjNrbFUwnTlAfmmAKC1MF06xZQjC1bEnilAUTw9jEleUr9tPkHN6eY/Iajz4qtmeSklxv78wHkxx2A4C2suxQvbr1NllG4UvkdOoU4sMPi/vly8UYv/zivK0cPiQlBfGll9Ty0qURT58WdfRbj/r0ySfGPNlRpN6uCIAcYLqKvN322GNqIN6kJMRixUT5qlWu988w+ZVs2Z5DRHj//fdt12UYJvfStSudvALI+Ii7GVY+mNLSAOrVE6fZvviCtq4yYt06ax9Ls2cDDB8uwpdkxM8/q76eoqPpJB8ABdj98Ufzds2aUaBaLy86qfbQQ2JbDQCgTx9abfLzE3m//grQr5/1XLZtA2jfXs1LTCT/Tjt3ArRpI/K9vMhnUs2ath4zndOn1ec9cIBcEmhs3UrPopGZU5EMw7jocmDWrFkQbydM+H90c8XLHMMwOUbHjgBbttB1SorzI/R6nPlg+vdfgLZtRdm1a2TD5AxEsh2SHTRqvP02xZVr3DjjeWnH+v38AAYNorz27UkwaOMEBJAdkxmaLdamTeRuQObLLwFGjVLz0tJI3Fy6ZN7fG2/Qc8mCqUwZgOvXSUjJIqZ4cfLnVLVqxs+p56WXhK+l7t3J8adsTtqjB+UBULy/CRNcH4NhmP/IkXWvAgJvzzF5gTZtxBZNaqprbe/cEW0rVhTbPw6HelpswgR7/a1ebb6d1bIluSL45ht7W3GjRhnzfv1VjBMb67x9RATiBx8Y83ftMp+3Pl6bPp07h/jII2per16Ia9eqeeXKuRazTubsWbWvffvU8gsX1PLw8MyNwzAFgWxxOcA4h0UTk9uRg7m6KphkH0w9e4r8sDD143zhQsZ9paQgVqpkbYuEiNiunT3BdOKE0f+RLERCQ63btm6txl8DoNh1165Zz/3ZZ637e/ZZxMREY77szgEAsWpVxOho196/zKuvir46dVJtlxARP/zQ/LdiGMYcjj3HMIzCffcBHDxI12lpxmP0zjh0SNjITJoE8OGHdD1okDgNNnAg2RJlxO+/05abnooVyY4oMdHoQbxYMfI0ricxEeD99wFSU+n+/vsB9u0T7b/7DuCVV8zn4eVFNkUa//d/ANOnW7+XK1cAqlSxfq4DByjcjNnpw0WL6G+dOgC7dqmx3VwhPBygRg1xv3s3wIMPivs7d9SQN1u3Gu2pGIbJPOxygGEKAMHBmRdMK1cKwbRgAQmm8HASHZpgCgvLWDAlJJC9kZlgev99Cq1y5IgIwaJRurRRMDVpQusoL7xAdjoAAN98A7B/vxBM7dtbCyYAag8A8NdfdP3JJ9bv5dNPrQXTAw+QLdWxY+buBrT5xsWRz6fMCqaxY4VgatOGxpQF08qVQjD5+5NLBBZMDONmcmjlq0DA23NMbqRuXbFVo9/GyYgZM0Tb7dsp7623RF7nzvb6nD3bektLs8V54w01v0ED8/qjR5P7Ajlv8mQxVlxcxlt6FSpYe/mWkW24zNK6dVRPv/2mpVatEG/fdumVG9CHkNmxQy13ONRt19mzszYewxREeHuOYRi45x7yUA1AKxOuOOmXA/eeOUMnz+T2O3aox+XNiIlxfnruzh1afSpWTA2w+8IL5m4BFi6kFR9/fzVf84TyzjsAH3xgPd6zzwL89JM9B56yl3M9Pj4UONjLy/ydPvQQnViTXRNkhrfeomDEAOQOYc8edTVM7zn86lVzR50Mw7gHj27PTZs2DR544AHw9/eHChUqwOOPPw4nT55U6iAivPvuuxAUFAR+fn7w0EMPwVGds5akpCQYOXIklCtXDooXLw69e/eGy5cvK3ViY2NhwIABEBAQAAEBATBgwAC4qYU4/4+LFy9Cr169oHjx4lCuXDkYNWoUJCcnZ8uzM0x2U7Vq5gXTffcJwRQbSwJC83NUpw7ZEGUkmPr0sRZMjz9O6yIbNpAI0ASTvz8JEjPBtG8fHdXv0EHNv3qVntPLy1owffYZjbd4ccaCCRGgeXNrwfT887T1FRlp9G3l5UV2Vps3Z00wRUZSX5pg2rKFnl8WTOPGCcH0wgs0bxZMDJPN5MzClzndunXDH3/8EY8cOYIHDx7EHj16YLVq1fC2tJ49ffp09Pf3x6VLl2JYWBg+++yzWKlSJYyPj0+vM2zYMKxcuTKuX78eQ0NDsWPHjtikSRNMlY4Hde/eHYODg3Hnzp24c+dODA4Oxp7SsZLU1FQMDg7Gjh07YmhoKK5fvx6DgoJwxIgRtp+Ht+eY3EKFCpnbkktLU7eCbtxQ7//6K+M+Fi92vqX1xx80Trlyar7+iL6c9Cf0NM/gEyYgPvGEdbtOnVx7b/oAt/q0ciW9z759jWUdOrg2lhWTJ4s+GzUynnLUu0/Yv9894zJMQSZPuhyIjo5GAMCtW7ciIqLD4cDAwECcPn16ep3ExEQMCAjAOXPmICLizZs3sUiRIrh48eL0OleuXEFvb29cu3YtIiIeO3YMAQB3SU5XQkJCEADwxH+xClavXo3e3t545cqV9DqLFi1CX19f2yKIRROTGyhVKnOCSe+DaeFCcV+sGOLdu87bHzuWsS1RRATizz87r6MXU3/+Ka6DgsimJ6NxZHsju7z2mmjr52fs7/x5xDffNB/rzTddG8uMqCi1zw0bjHXk3+Tee113G8EwjDl2v9+56vRcXFwcAACUKVMGAADOnz8PUVFR0LVr1/Q6vr6+0KFDB9j531nh/fv3Q0pKilInKCgIgoOD0+uEhIRAQEAAtGjRIr1Oy5YtISAgQKkTHBwMQUFB6XW6desGSUlJsH///mx6YoZxL8WLA2i7zq5syUVGilNrjz5KXsK10CA//EC2R1bbWtHRtKXWoIF1/5Uqkefw2rWFt24zypYlj9kaL71EW3kAtMV2+bLqcdyK+HiAhx/OuB4AjeflBTBzpsiT7asAKIRLzZpiu0xmwQJyVZAVPvxQBNGtW5e2P2Wv5GlpdHJO+01+/ZXszGTP7AzDZD+5xhAcEWHs2LHQtm1bCA4OBgCAqKgoAACoWLGiUrdixYoQHh6eXsfHxwdK687xVqxYMb19VFQUVDDZ7K9QoYJSRz9O6dKlwcfHJ72OnqSkJEjSQp0DuBRihmHcTZEi9LEtVEj4LbLDwYNkwwQA8NxzwqcQAB2TL1nSvF1CAkCLFuQmwBlTptDcfHwynktMjHo/dy79PXGCxIT0/zSmDBpEht52mTsX4OWX6bpyZfLFJFO8OAnG2bPN24eEALRsaX88PdevC1sxAIC1a43x9/bvJxsrDTnOH8MwOUuuWWkaMWIEHD58GBbJ/8X+Dy/d/y4joiFPj76OWf3M1JGZNm1aumF5QEAAVM1M4CiGySKItFKSmkrGx64IppUrhWCqXl0IpunTqV8zweRwkK+l4sUzFkxbt9LJtrfftq7TqZN1WcmSJM4mTKBnjIx0PpZdwZSSQqcBNcFUp45RMAGQYJKR/xW/eDFrgunjj4Vgql6d5qQXTIMHC8E0fjz9JiyYGMZz5ArRNHLkSFixYgVs3rwZqkge5AL/W6/Wr/RER0enrwoFBgZCcnIyxMbGOq1z9epVw7jXrl1T6ujHiY2NhZSUFMMKlMaECRMgLi4uPV2yitzJMNkEojhRFRBg7jXbis8/B+jdW9z/t3gLkZEAb75p3mbyZFrJ+v13Y5neDcCgQXTSDdF6Ds8/TwFyzRg7lpw1FisGsHy5dR8AJG7sOnLcupVWveSF4VOnzOvKW4ElSojgvLdvZy64LgDAjRskAN96i+5XrgS4cEENmnz1KtXRHIYeP04ONhmG8TDZb15ljcPhwNdeew2DgoLwlBZwSlceGBiIH3/8cXpeUlKSqSH4kiVL0utERESYGoLv3r07vc6uXbtMDcEjpKBVixcvZkNwJtficAij4PLlXWs7ZIjRmHnUKOv6P/7o3Oi6Xj1x3aqVPUPtKlXs1XOWXDjcig4HYvfuoq2zGHKffEJG52ZlaWmuvWsZ2VlopUqIycnGOjNnijotW7rukJRhGNfJE6fnhg8fjgEBAbhlyxaMjIxMTwkJCel1pk+fjgEBAbhs2TIMCwvD5557ztTlQJUqVXDDhg0YGhqKnTp1MnU50LhxYwwJCcGQkBBs1KiRqcuBzp07Y2hoKG7YsAGrVKnCLgeYXIksmCpXdq1t06ZGIXD6tHndjRudixYfH/Ve9j5ulXr0cE0YyUJHTtJh2Aw5d05ta/YOABCnTUOMiTEve/BB196zjN5NwPLlxjpJSXRKUavz99+ZH49hGNfIE6IJAEzTjz/+mF7H4XDglClTMDAwEH19fbF9+/YYFham9HP37l0cMWIElilTBv38/LBnz5548eJFpU5MTAz269cP/f390d/fH/v164exsbFKnfDwcOzRowf6+flhmTJlcMSIEZiYmGj7eVg0MTmBLJhq1LDfTu+DCQDxqafM6x49mrGYmT7d9ZWhjz92rf6uXeb5Lvxrqfg9shJgAIgpKao7g44dxbWzVbiM+OYb0U/p0uZz37pVncudO5kfj2EY18kToim/waKJyW5kwVSnjv12ZjHUzJwiRkUhFimSsZj59FNx7eVlTwCNH29fLP3vf+RnSZ8/bpz9Z46PV9sOHmw+Vps2VP+DD0Te6NHi+vvv7Y8po4+B99tv5vUefVTUmTo1c2MxDJM1WDR5ABZNTHYirxQ1aGC/XUSE+vFu0cJoJ3PnjvCy7Sx9+SVi27bmZbIXcjn17IlYrZp1n716ieuSJSnA7ZQpxnqhofaf+bffRDu9s0w5TZ5M70J+9nHjxPWWLfbHlPn2W9FH8eLmjkEvXFDnEh6eubEYhsk6LJo8AIsmJruQBVOTJvbbbdumfpg3blTLU1MRn3zS3urPtWuIhQplXE/2pv3LL9b1evdW7/87t4HNmqn5Xl7mBtNmpKYi1qqlCha5L3l7bsUK42rU00+L67Nn7b9njVu31P4WLjSv99FHok6PHq6PwzCMe8mTHsEZhjGSliY8PzdvTs4o7fDaa+IYfunS5AdI9ok0aRIdc1+6lO71gXA13nkH4OhR8imUlqaW6f0KAQhv2nPnAvTvb95nvXoAK1bQdffu5PupQwc6Zi874C9Visr0gXHNCA2l5zlzRuTJfpa6dyfnkQAAJ0+SM0vND1WHDgDVqglXCnFxAPfck/GYMj/+KNwuFC5MYz//vFonIYGecdIkut+6lYIhMwyTN2DRxDC5mLQ04b+ndWuAvXszbnP3LvlumjWL7t9/n3wDaf388AN9uKdOpfvXXqO/W7ca+4qIIIeZDRuq+ZqI+ecfY5umTenvSy9Zz/HECfp76hTAmjXkp8jPz1jv2jXrPmQGDgRo1sy87LHH6K8mmOLjaUyt/hdf0LNfvEj3qanWXtDNSEig9z1kCN3/9BMJ1GLF1HqrVolQNSVKACQl2fctxTBMLiGHVr4KBLw9x7iTlBSxhdOhg702S5eq20NHjoiy9evVsv79ETt3Nt86e/VVahMcbCxr2VK99/W1t70npylTxLxWrjSvY3YsX4/eXkufFi8W1/7+ZL8k22Rt2SKuGza0+cNI6Lcfb9821nE4yF2BVmfWLNfHYRgme2GbJg/AoolxF8nJ4iPbpUvG9VNSjMbWN29SWViYmv/gg+Yn07R0/rz5aTt/f9fFkVnS5oVoPFH30EP0t2TJjJ/5rbecjyPbcz3zDGJCglq+b5+4fvFF136fhARVLM6da17v+HF1zKtXXRuHYZicgW2aGCaPkpwsgts+8gjA+vXO62/dSttl2vYSAG0PadtGjRpRXkAAbbfFxgJ07Wrs56mn6NN++rTYRtIoWxbg1i1787eIOgTLl1P/AQH09957AT77TJT/+y/Ali10bREjGwAA9u2j7cXp083LmzYF+O03sfX19dcUNFjbLmvalLYVtZhuX38tAgPbYckS6kuL1R0fD/Dii8Z648cD1K9P14MG0TObxA1nGCYPUTjjKgzD5BTJyQC+vnTduzfAX39Z10UEaNeOxIZGpUpkJ9S4McUr0zh1CuDwYYCgIPO+jh8n4+y2bdX+SpcmkRUTYz2P/v0BfvmFrgMCKG6aTOvWANu2CWP2hARVlPn4kB2W9tw//WRu37R/vxA6VsycCXD+PAUUBqBxT50SNllTp5KxtmbAvm4dwMMPO+9TIymJBGFcnBjr1VeN9W7epPemsW+ftb0VwzB5jBxa+SoQ8PYckxUSE8U2zpNPOq978KBxO6pXL8THH1fztm8nOxt9uBN5OwzRGGbETjp40Ln/JQDEw4fVeZ88qZb360f5su2Rnp07jf126mTMO3WK3DFo95cvqz6gdu5EHDpU3P8XdtIWelsxeYtR5tdfRZ2aNckFAsMwuR+2afIALJqYzHL3rvjY9u3rvG7fvkbB0Lq1ev/rr1RXDv6qT/v2kZFyz55qvhz/zCy1akU+m5zV8fc3zvuHH9Q6mzdTflKSyJP/1ZGNtJ2lIkWMNlh6/0s3bpBDUPneDklJFAxZa/f55+b1UlNJJGn1rPwzMQyTO7H7/ebtOYbxMHfvCnubAQMA5s83r3f+vLXvoJ076e9HHwFMnAhw/TrZ/ZjRoAHAkSPUxtvEqjEhwXquv/wCULUq+WwCIPsgvd+o2rVpS0ymSxeAjRvFfVKSsNuqWZP+zphBR/3XrTP3/9Smjbp1CEB2Q2PHiu2++vUBVq4ULgOqVQM4e1b185ScbM/v08qVtEWqceOGuu2mERqqbr/FxpJ/KYZh8h9sCM4wHiQhQQimF16wFkzjxgnBVK+esXzwYHICOXEiwNtvC1GjN+jesAHgwAHqq21b1+YaEUH+lTQnmFWrGgXT/ferggmRxJEmmFq2FHkA5DspIoKu772XhJ6ZYPL3NwqmHTsA+vQRdlqvv04G37Vq0f1bbwGEhQmBVL06jZ2RYEpJIbGlCaZPPqF2ZoLphReEYBo3juqxYGKYfEwOrXwVCHh7jnGF27fFds5LL5nXuXpV3WbSx31r1YpsoRDJVYBcVrKkuK5UibaQ9FtkdlKzZhTGJSP7JS3wrYY+ttpPP6nlqanm/QQGiuvKlc3r3LqFOHu2uF+0iPxOafcbNlAYFO3++eft/SarV6vjXL9u73c5ftxe/wzD5E7YpskDsGhi7CLb3Awfbl7nk09EnXr11I90qVLqB33QIFEmx14DICNr/UfebvrpJxono3oPP6zO/dNP1XIz/0R6Eda4MWLZsuK+Rg3jOL17U9t+/UTe/v3GsWR7qE8/zfj3SElBvPde0eajj6zrzpol6pkFP2YYJu/BoskDsGhi7BAXJz66o0YZy/VGzFWqWK9q6E/R6YPVJifTGM4Ez7ffmudfvoy4dau49/Iyr6cJGQ1ZfJQoYRQV332ntm/VilaGMhJmf/xBfZUuLfIOHxbX/v60IjZ3rshbuTLj30PvKd3KAWVSkhoA2E7fDMPkDVg0eQAWTUxGxMaKj+7Yscbyn38W5YULqx/zypVFPYdDeM8GMB7B//prxEOHnIuQJUsQP/7YmN+oEfX/9tsZCxn5pF90tFo2aJD6bF99ZWx/8iTiY4+Je/2KmpYiItTtTADEP/8U11rYl5EjRV5YmPPfIjUVsX59UV8O7aJH9i4OQKf1GIbJP7Bo8gAsmhhn3LghPrpvvqmWJSZahylZskRdrdm8WS2XxZO3N9n7tGhhLXQefZT6u+8+Y9ncuVRWtWrGgmnwYDEn2T8RAK0caeiFWbly9Pe55zIeo3Ztms+ZMyKva1fE114T9ytW0DhyfLfoaOe/hf4dRkZa15VdMjjbtmMYJu/CoskDsGhirJDtgiZNUstWrTIXDNOmqfWSkxHvuUeUDxmi1p84kYLcOhMhp0+rTjTlFB5uz34JQNhhmYkv7R//995T8596So33piXZdql2bXE9Ywb1Ixtnf/ihauB+8SJtycn9JSVZ/w5paep8J0ywrhservZ74YJLPznDMHkIFk0egEUTY4bsCFLeAtJvD8liSG8H9PvvxlUe+V4+KWaWRoygfsy27OrUofGcOZMsVUpca9uKERFqnfLlqZ8331TzBwwQnrGdzVG2Fzp6lOrLwmvJErV+Sgqtqmn35co5N8revl1tf/mydd2pU0W9Hj1c+rkZhsmDsGjyACyaGD3yqbUPPhD5ZqFB2rQR7gM0bt1CLFRI1HnvPdUg+7nnVI/VZikigvr64ANj2axZVPbWW9btZW/jEydS/Z9+UusMGqTaEwEgvvIKrexotG8vyooWVUWb2UqRvO34yy/iWgu9Iq8E6Y3RZdLSEFu2FHXHjbOuq/csvmVLhj8xwzD5ABZNHoBFEyMTGSk+vtOnU57DoYoHADpmHxNjbP/112q9d95R7/UrJ/pUrZpYeQkONpafO0flZcpY9/HCC+L6/fepvr6vhx9W719/XV3xSUszukHQ0ujR4loz5tb7b/q//xPXixZRHVl0vv++9W8QEqL2FR5uXVfeJi1Rwvk2H8Mw+QsWTR6ARROjIW9dffYZ5e3ZYxQNZ88a2+pPof3wA6KfnypS5BNnZknbBpRj2mmpRg0SMidOOO9D3hr75BOjjY8+TZhg3B4zCywMQFtx8uqPFodOtqkKDESsXl3cnzlDdRYsEHl//GH+/vXidORI69/K4VCNyGfOtPcbMwyTf2DR5AFYNDGIZCujfYA//5xsb/Sn0XbuNG87YYKoU7680aeR7IPIKmlbSnqnjwCIX35JZU88YSzTTrUBIH7/vbj+4gvVoaM+Wa30DB1qXl+/gnbzJtU/cEDk6U/WaduWb7wh8vbvNx9371617blz1r+VXjhGRTn7ZRmGya+waPIALJqYixfFB/irryg8ivxR1lad9Jw7p9ZbtQqxYkVx37ChGl7EKmmOGc18LJ05Y73yIx+rl0/gzZpl7pkbwNrTtjPv40uXiuvOnUUbefVItq+SjbBlGyczFwEOh7pV+Morzn+r8eNF3YEDnddlGCZ/w6LJA7BoKtjI21d9+6pioWZN65Ndcsy05s2NLghkux+rVLy4MLrWG1YHBZG7gmbNzNs+9ZS43rhRXJs5vtRWiqz45htRr1gxcT10qOoi4ZdfRJtXXxX58vX331O5w6E6+kxIMI4rr1JpAtGKmzfVuvv2OftVGYYpCLBo8gAsmgo2lSqZiwyrE1j6D/3u3aoLgoxOxWnp5ZepPzP7pf/9z+iuQEtly6q2PLLR9DPPGOs785idmIjo62s+jmyXBECrcYgkhmQDcdnA/MgRqpOQIPL8/IzC0+FQV8lkh5tmyE44a9QQrhAYhinYsGjyACyaCi56AaR9lFNSjHXT0hDbtRP1+vQx2uHIW1H6JIuzpUupz3//NdbT9ymnDz9E9PER97KRure3sb6zf6TtxI0DoBUvbTXMTOBpSQtRIhvT6wMCI6px5wDIPsmK1FTVMai80sUwDGP3++0NDMNkmitXALy8AO67T81fvhzg/HmAwoXV/M2bAQoVAti+ne5PngS4cQPggQfovkgR+rtli/l4QUEAkZF0fe4cwBNPAIwbB9CmjahTpgzAxImiTz0HDgC8/TZAcjKAnx/A7t0ADz4oyh0OcV2uHN2XLGnsBxGgUyeALl3Mx5GZOpXelbc3wKVLNC4AQIMGok7r1tRnsWIA+/fTswIATJgAsG6d2t9TTwE0bkzXzz1H7erWNR87NJR+h3Pn6D42FqBfv4znzDAMYyCHRFyBgFeaCg7x8WSnpF8lKVzY3OYmOVk1qB49mkKayG2dGXrLsdYAhA8hvZH22LHWffj4qN7JW7VC/Ptv6/ovvWT9/KdOmbd55BHVrgmAjM81ZK/jstH2F1+IOr/9JvIXLlTHPXpU7VvzHG6F7GfKLEAywzAMIm/PeQQWTfmflBTE7t3VD3dIiCgzQx/+IyIC8dln7W1pASCuXy+uu3enPm/fNtZzFqR30iSKnabdP/ccOXC0qr9kifU7kI/9y2nnTsTjx9W8u3dFu88/F/my/ZJsiP3uu8b3qvH886LsySed/076E3zHjzuvzzBMwYZFkwdg0ZR/cTiMp9g0eyIrbt1SQ558+qkxXpuztHAhrcBo97NnU7/yCTcANSSJWTpwQLVvkk+imSVnAuPPP43169cnmyE51Enbtmq7xx83H0v+V0U26NaMxRERT55U2xw65Py9z54t6j7wgPN4dAzDMIgsmjwCi6b8ycyZ6kfbyteSzJdfqm1u3kQcNcqeWGrUiFatOnRQhQ8i+R6S68oCyGylKSnJXOhYpdu3nT+X3lv5ypWU36WLmq+RloZYpIhxnIYNhZhxONSAwPIc5O21nj2dC6DkZER/f+PcGIZhMsLu97uwtbUTwxRsVq0C6NlT3L/yCsDs2WT47YyffwYYPZqu588H6NEDoFQpe2Pu30/G0ZpBOABAfDyAvz9AYCDA1atq/dRU+hsURAbdGmPGAMyYQQbh06ZlPO699wKcPu382ZYsAejbl679/MiAPSnJ2CYuTsw7IICuCxUCSEuj6/ffB5g8ma6TkgCKFhVt09LIWPzMGYDatUV+aKjR2F5m+3aA9u3F/Z07ZFDOMAzjTvj0HMPoOHCAhIAmmDp0oI/7nDkZCyYAgEceARg+HCAxkU6KlS2bcZtXX6X1EX9/cbKsfn06ueZw0Lh6wQQAMGsW/Y2IEHm7dgG88AK1kQXTyJHmY48bRyLF6tlSUgAqVRKC6fvvARISaBxNDGoib8YMOml34oQQTJUqCcG0fbsQTNHRQjC1akXP7+0NMGyYEExdu9LzOxNMvXsLwfThh9QPCyaGYbKFHFr5KhDw9lzeRg6BAkD+kGJjM9fXrVv2t8S00CeLFok8zZHkihVqXS2GXcOG5v6Rduww5u3ahdi1q/nYf/3l/Dk2bVLra+9DPs0n23ohqmFY5HT9uuhX9rE0ejTlnT+v1t+71/nc9AGEL1yw++swDMOosE2TB2DRlDeJizN6rT5/PvP96YPsWqUffhBtBg4U+Zs3U558Wkyzazp3jtKkSWrZY4+ZjxEbaz3+2bPWz+BwkEsCra4WlDcpSe1DdpsQHa3GjZPFp2yL9NdfomzePMobOVLkdeiQsfH21Kmi/qOPuvTzMAzDGGCbJobJgJQU2oKTHSfu2WPtFDIjEhNpSyo5me6LFCH7noEDAf74Q9S7916AY8cAfHxo26pIEfr8A9AWXPnytMV165Zok5RE9REBqlUDuHxZHfuvv4zz2b4doHRp87kmJIhtQD2HDgE0bSruL18GqFyZ5tywIeWVKgVw/TrA/ffT/dtvk+3W3r1qX+PHA3z6qbj/5BOAN9+k623bAGrUULcFd+6krTorEhIAihcX95s3Azz0kHV9hmEYd8I2TUyBAxFg1CgSIZpgWraM8jMrmJYuJRGiCaavvgIIDyfbGlkwhYSQ/ZCPD3n2LlyYxvXzE3Y/3t5CMA0bRuU+PgAxMVSmF0wA5AVco2lTgBdfBGjXzlivaVMxnhn9+gnB9OKLVLdyZbJV0gTT5MnkVXvXLoDDhynvww+NgmndOlUw9e0rBNO5cyT0qlWj+xYt6PmdCaY1a4RgKlaMhCQLJoZhcpQcWvkqEPD2XO5H7616xoys9ZecbAysGxNj9Mw9YIDaTnZY+eKLlLd0qbVNj+xJW05VqpDHbe3+ueest+Peecf6OWTHlwDC07bDgXjvvSJ/zx6R72zrMTJS7V+zxQKgGHFy3e3bnb9jhwOxZUtRf+bMjH8XhmEYV2CbJg/Aoil3k5oqPrzDh2fd6eHaterHf/Roo3EyAOKVK2q7CRNE2R9/UN7QoWqbxERRf+JEY5+1a5M4kwMFDxliLWLWrrV+DtkO6eGHxXvRO+LUAukiGv0yaaloUXrPGsnJark81n33iQC+VugdW0ZFZfSrMAzDuA6LJg/Aoin3c/o0fcizQloaYt266sf83DnEQYPUvG++Uds5HGq8urNnqS8/P5E3eLBaX3b6CEDhR7R/vFatEvlTplgLJtm7towchw4A8d9/Rdkff4j8vn3VdvLKlpxeflmtFxMjyurVU+tu2pTxe/6//xP1Bw7MuD7DMExmYdHkAVg05X/+/Vf9+D/yCOKZM2peuXJqzDVE8giuX0nSuziQRYscpw0AsXRp1VP2rFmibNs2EihBQUYhowX21fP11+qqlbw61Lu3KFuxwtjWTDAtX67WkWPQ3X+/uG7YUB3LDP27kmPTMQzDZAd2v99sCM4wNkAEaNOGksbu3XTyq1YtkbdlC8C1a6qX69BQ4QSyWzfqa948YQQNAHD3LkDr1gBff019jhkjypYuJe/bmhH02LHkDBMA4ORJMvh+4w3VwWW7djSOj4/6HAkJ1L/m6PLPPwFOnSKP3bdvU9mKFVQWHQ3Qq5f6DswMyMPDAR5/XNz/8w855pSfH4AMw48cobGsWLxYvKsaNcjjebNm1vUZhmFylBwScQUCXmnKn8h2QwBkGK3P69LF3EZKXtGZNYvymjcXeZqPoU8+MV/BiYlR+3vkEVF27Rrl6f05TZtm/hy//y7qFC6srobJK2iNGxuf5c4d8/nptzr1Mfe095WS4vwdp6Yi3nOPaPPLL87rMwzDuBPenvMALJryH/JWFQAFv5VFD4C1J+rOnUWdAwdoS07f13vvmYuR1q2N/TkciL6+VK4Jnj591HZbthjbpaSop9fmzFHLx48XZWYn086dM87v2WeN9eTgulpavdrp60VExNBQtU1mvbAzDMNkFnZuyTBZ4ORJgHr11LxVq8iBo8a4cQCffWZsqw9CGx9PTjPlvDFj1C0tmUWLRJw3GS8v2qbz86Pr7t1pK0wjIoLivMls3ar6MrpxQzi8TE2lvrSgvydPAtSpo7Zft462FGV++YX8OcnUr0/x5jSqVgU4e1YNPGzG0KEAP/xA11qQYYZhmFxLDom4AgGvNOUP5OP/XbrQKTV5paZIEdUoW0YOK1K3Lq0O9eunGonLqyrdu6v3Why6jGjTRm2n3/5yOBDbtRPleh9Np06pW3Vm22dyqBItnTih1pHdOGgpo3h2iPSccptjx+w9N8MwTHbAhuAM4yLh4bSCM28e3YeGAgwYQKtLly5R3vffk9dvOZSHxm+/AdSuTdeTJ1PYkWLFABYuFHWuX6e/o0cDPPMMwNq1dF+rFoDDAVChQsbzbNgQ4N9/6bprV5IdhaU147Aw8hy+fTvdX7wI8N57onz2bLGiNH48hZMprFtz7toVYOJENe+ffwDq1hX3cXFqu/LlaZWtd2/n8//2W4CKFem6eXN6btlwnGEYJteSQyKuQMArTXkX2a6nXTuyPypWTORVqeLcGebgwaLupk3kUdvMVmnCBKNvps8+sz9P2a3A558by+XAvy+8oJY5HIhNmojyHTuM7c1WjgAQ69RR6+kN4ZcuzXjuycmIJUuKNmbuDBiGYTwB2zQxjA2iolQ7oO3bAdavV+2PNmwA6NzZvH1aGoCvr4gbFxUF8PnnAB9/rNZ7/31afbpwQT1yf+4cQM2a9uZaogTAnTt0vWOH6v7g4kWA6tXF/ZEjIlYcALlBkFexbt2i/mRiY9UYdjJHj4rrMWMAvviCrosWBbh5k96BM3bsUGPh3b5tvlrHMAyTm+HtOabA8tFHQjAFB5Mhdbt2JHAAKIgsorVgioqi7SlNON25QwbQsmD65BPqY/JkMnLWBFLJkrQtZUcwORy03aYJpqtXVcE0aZIQTJ06UX1ZMK1cKQRTr140H71gCguzFkx//UXPeesWbV9qgumNN8i/VEaC6bHHhGD64AManwUTwzB5khxa+SoQ8PZc3kAO7wFAcdmGD1fztIC1VmzYIOoOHIjYooXafswYtb4cP27IEPtzvXHD2uBb/xzbthnbP/usKP/9d/MxFi0ybsdpHslLlaI6c+eq5Xa8dOs9np8/b/+5GYZhchL20+QBWDTlfmRnk5Uq0cdf/rD36ZNxH2+/LerXqmUUHHJgW4cDsXJlUSaHSskIeW5eXmqZHEalZk3j6Te9M8qICPMxRo9W67VogXjrlri/ft34fJpTTWdMny7qP/KI/WdmGIbxBGzTxDASt28D+PuL+99+A/j0Uzq9BQDQpQudDvN2smGNSKfHTp8WeWfOiOvmzQH27hX316/TiTKNxMSMt7I0vv0WYNgwui5alLbBAOhvsWKi3rJlAH36qG337gV48EG6rlWLwqR4eRnHaNAA4Phxcf/ZZ+R7Sjs199JLAOXKqW2SkoyhWWT089u8WfUTxTAMk5dhmyYm3zN/vhBMvr7kAuCZZ4TAOXGCjL+dCab4eCqXBZPM7NmqYNqyRQimPn1IcNkVTE89JQRTuXJCMC1bpgqShASjYHrnHSGYPvuM5qsXTElJlCcLpj17SDABALz9NkBQEMDcuaK8YkWylXImmNasEfPz86NxWDAxDJOfYNHE5HveeYf+zpxJH3LNm/XkyWL1yBkbNwIEBFiXnz4tRA4AGWZ37EjX8+eT2LFDWhqJmaVL6b5GDTr1lpYGcM89AE8+KZ4DUQ2em5ZGgW4/+IDujxwRIkgmIkI9GQhAp98eeEDcI6rBf/v0IaN3s9UqrX6bNgCPPkr333xDgs6ZwGIYhsmL8PYck+/Zvh3gq68AXntN5N286VwIAQBERgLce69Y6QEg55XyalNysggVgkin565coftTp4Szy4zQuwRo1Ajg8GHjUf2YGOMpt/PnSVRpWG2h6fuqU4dW2fRi6NAhcf3BB7TyZMWpU6rojIwECAy0rs8wDJOX4ZUmJl9z4wZAtWoiRtzSpSRuMhJMq1fTFpUmmLT2mmC6cYP60QTT9eu0facJpsRE+4IpJEQVTC1bknDp1EmInEmTaDy9YPrhByGYXn2V6pgJppkzVcE0ZQrFmtMLpvnzhTuDpUudC6Y33xSCacAAGpsFE8Mw+RleaWLyNTEx9Ld1a4Bt21THklYkJamBeb//HuDFF+m6Vy+AFSvU+lu2iO24Pn3sb8cBkM+jMWPEfceOAF9/rdpXhYeT8NPTpg3Azp107czgum9fgCVLxP3WrQDt2xvrvfEGGccDUAiZ++4z7y8ujrYCNfbuFQb1DMMw+RkWTUy+pnZtMmC2ssfRc/YsnTjT2laoIATTihUkmmQmTQKYOpWu58+nFRe7PPKIiD0HQEKtQgVytAkAMHAgwM8/G9vpPXdbbTUikgG85hQTgLYB9SfiAEisbdlC18622H77DeDZZ+m6enV6X3aEKMMwTH6ARROT77ErmH7/nU7VAQC8/jqtAmnbcXpboqzYL6Wmim09jR49AFatEveHD5Ndk5516wC6daPrzp0pxIsVq1cLwVS+PHkS178LLdivw0H3d+8aDcUBqLxuXeFiYcECgP79rcdmGIbJj3jUpmnbtm3Qq1cvCAoKAi8vL/jzzz+VckSEd999F4KCgsDPzw8eeughOCoHwQKApKQkGDlyJJQrVw6KFy8OvXv3hsuXLyt1YmNjYcCAARAQEAABAQEwYMAAuHnzplLn4sWL0KtXLyhevDiUK1cORo0aBcnJydnx2Ewu5Px5IZgmTxahQrp1M9oSZcV+KTLSKJgaNxaCqX17EihmgmnoUCGYFixwLpiWLQPo2ZOux4wBiI42Cqa7d+k5HA4Ka+JwmAumgwdpNUkTTDdusGBiGKZg4lHRdOfOHWjSpAl88803puWffPIJzJgxA7755hvYu3cvBAYGwsMPPwy3bt1Kr/P666/D8uXLYfHixbBjxw64ffs29OzZE9K0CKoA8Pzzz8PBgwdh7dq1sHbtWjh48CAMkPZR0tLSoEePHnDnzh3YsWMHLF68GJYuXQrjzM5sM/mSKlUAvvyS7IS0Y/vLlqnbZwBZ87+0ZQsZl+s5fFiUb91qFDeJiZT3ww90f/Gic9Hy4ovCPcGaNRTzTs+VK8KnUteu5PzTbEXupZeEbdOYMfS8pUtbj80wDJOvyRkH5RkDALh8+fL0e4fDgYGBgTh9+vT0vMTERAwICMA5c+YgIuLNmzexSJEiuHjx4vQ6V65cQW9vb1y7di0iIh47dgwBAHft2pVeJyQkBAEAT5w4gYiIq1evRm9vb7xy5Up6nUWLFqGvr69LIVE4jEre5dq1jEOFyPHjfvnFtf6nTTOGI9FS1arGMCgaBw+qYV/S0qzHSE1FLFxY1Jf+cVbYu1fUmTjRvE50tDrHY8dce16GYZi8hN3vd651OXD+/HmIioqCrl27puf5+vpChw4dYOd/R4b2798PKSkpSp2goCAIDg5OrxMSEgIBAQHQokWL9DotW7aEgIAApU5wcDAEScsA3bp1g6SkJNi/f7/lHJOSkiA+Pl5JTN5j+XKxetSxI8kE2VgakVaiNIPv06eFg0w7tGsHMGGCednvv9PKUWET68KpUwGaNqXrDz8kh5NWXssjI6mP1FTx12xV67ffhCPLX38F+OgjY53vvhMuEO6/n7bt6td3+ogMwzAFglxrCB4VFQUAABUrVlTyK1asCOHh4el1fHx8oLRuv6BixYrp7aOioqCC7ATnPypUqKDU0Y9TunRp8PHxSa9jxrRp0+C9995z8cmY3IR8gu233wCeflot18ePyyj2mkxysvOtuzt31LAoGg4HGZlrXrkPHBDiyYx//gHo3p2uhwwBmDfPvN6UKQDvv0/Xu3eLcCsaKSkkljRzP7PTggzDMAWZXLvSpOGlM7RAREOeHn0ds/qZqaNnwoQJEBcXl54uXbrkdF5M7uHGDbLh0QTT1atGwSTbLz3xhLXjSDMuXxaCqWZNke/nR97JEc0F06VLZHStCaa7d50LpnHjhGD64w9rwdSzpxBMly4ZBdOOHfRsmmC6fZsFE8MwjJ5cK5oC/3MUo1/piY6OTl8VCgwMhOTkZIiNjXVa5+rVq4b+r127ptTRjxMbGwspKSmGFSgZX19fKFmypJKY3M/ffwOULUvXrVvTyo5+MVKOH/fLLyIenF0OHKC/r7xCJ/MAyCA7IQFg5EjzNr/+KpxYDh5MwsrsNBsAlVWsKIy8z58Xxt/6egEB4nTenTu01SjTp4/wFv7++9SmeHFbj8kwDFOgyLWiqWbNmhAYGAjr169Pz0tOToatW7dC69atAQCgWbNmUKRIEaVOZGQkHDlyJL1Oq1atIC4uDvbs2ZNeZ/fu3RAXF6fUOXLkCERGRqbXWbduHfj6+kKzZs2y9TmZnOXxx8UKysKFAP/+q54ay6r9ksajj5Jw+vZbup85U/X8radrVzHOP/8A/PijdV3N5UF0NN0nJ1NwXz1JSVRPM7VLS1NXty5domfXPH2cP0/uFhiGYRgLcsAo3ZJbt27hgQMH8MCBAwgAOGPGDDxw4ACGh4cjIuL06dMxICAAly1bhmFhYfjcc89hpUqVMD4+Pr2PYcOGYZUqVXDDhg0YGhqKnTp1wiZNmmBqamp6ne7du2Pjxo0xJCQEQ0JCsFGjRtizZ8/08tTUVAwODsbOnTtjaGgobtiwAatUqYIjRoxw6Xn49FzuJTZWPQ0WEWGsoz9Bl5SU+fGuXxf9fP+9db2bN9UxY2Kc97t1q6j75JPW9aKiRL02bYzlmzaJ8u7dER0Oe8/FMAyTH7H7/faoaNq8eTMCgCENGjQIEcntwJQpUzAwMBB9fX2xffv2GBYWpvRx9+5dHDFiBJYpUwb9/PywZ8+eePHiRaVOTEwM9uvXD/39/dHf3x/79euHsbGxSp3w8HDs0aMH+vn5YZkyZXDEiBGYmJjo0vOwaMqdrFkjBELz5uYCYfNmUeeJJ7I+ZmQkYpUqiAsWWNfZskWM2apVxn2++66oP3++db1Dh0S9MWPM62jPu2lTxuMyDMPkd+x+v70QET21ypXfiI+Ph4CAAIiLi2P7plzCM8/QsX4AiuM2cKCxjhw/7pdfMrcd5yojRwJoPl2//568fVuBSEf+T56k+xMnKKSJGX/9RVuQAOQM84UX3DZlhmGYfIvd73eudTnAMFkhPl4NYnv5MkDlymodffy406dFsN7sQu+G4Nw59XSdnrg4gFKlxL1VbDgAgOnThT+o7dsB2rbN8nQZhmEYiVxrCM4wmWX9eiGYGjem03F6waSPH5eUlP2C6dgxIZhKliQHlM4E0759QjB17uz8NN0zzwjBdO4cCyaGYZjsgEUTk6/o359OogHQttehQ8aYalnxv5RZPv8coGFDup40iVaQChWyrj9jhvDcPXOm8+C8HTqILcj4eOdCjGEYhsk8vD3H5Atu3wbw9xf34eHC55FMTtsvIQLUqQNw5gzd79kjxJAV//sfwPjxdH3wIECTJs7rOxzkSiA+3rkQYxiGYbIGiyYmz7Nli3BEWbcuwPHjxtUlRPJldPEi3eeE/VJUFEClSuLeKmyKnlataG4HDgCUKJFx/W3bjM/LMAzDuB/enmPyNKmpQjDNnk0ny8wERFycEEw5Yb+0dKkQTM88Yx02xYzWrUnU2RFMACyYGIZhcgpeaWLyNN7eAJs2kR2PmVdsjVKlKISJn1/2z+nxx+noPwD97d07+8dkGIZhsh8WTUyexttbrDRlRHYLJr1dVXS0MDhnGIZh8j68PccwbiAkRAgmzc0BCyaGYZj8BYsmhskib7xBdkgA5B7AzM0BwzAMk/fh7TmGySSpqQDFi5OXbwAKc1KnjmfnxDAMw2QfLJoYJpOcPk2CqVAhgMREgML8bxPDMEy+hrfnGCaT1K1LMe1SU1kwMQzDFARYNDFMJvH2Nsa0YxiGYfIvLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGhT09gQLHrl0AZ8/m3Hi1agG0aJFz4zEMwzBMPoVFU05y+jRAq1Y5P+6pUwC1a+f8uAzDMAyTj+DtuZwkPr5gjcswDMMw+QgWTTmJl1fBGpdhGIZh8hEsmhiGYRiGYWzAoqkg0KwZQOvWnp4FwzAMw+RpWDQVFEJCAPz8RBo3zrzeoUMAzz0HUKYMgLc3pZIlAUaMEHW2bAF47DGASpUAihcHaNoU4KefAEaOBChXjvJ69wa4fFntOzYWYMAAgIAASgMGANy8mT3PyzAMwzBuhkVTQaFQIYC7dyn16wcQGWleb/9+EjuFCgHMmAHw6acAyckAKSmizs6dAI0bAyxdCnD4MMCQIQAvvACwaBHA4sUAO3YA3L4N0LMnQFqaaPf88wAHDwKsXUvp4EESTgzDMAyTB2CXAwUFh8NevT59aFVp5UqAzp0p79w5gOPHRZ2JE9U2gwYBvP46QHAwQJculPfLLwBVqwJs2ADQrRu1X7uW/FRpfqPmziUXDCdPAtStm6XHYxiGYZjshleaCgqI9uqtX08C68oVgPr1AapUAfj7b4CiRa3b7N9P/QcHi7ygILrfuZPuQ0JoS052tNmyJeVpdRiGYRgmF8MrTYzKuXMkmqZOBfjyS4CLFwFeeYXykpMBfHyMbf76i/4OH67mV6wIEBVF11FRABUqGNtWqCDqMAzDMEwuhleadMyaNQtq1qwJRYsWhWbNmsH27ds9PaWcxeEg+6WvvqJVpkmTAN58EyAiAmDzZmP9LVsAvv0WoHBhgIYN1TJE1UeUmb8ofR2GYRiGyaWwaJJYsmQJvP766zBp0iQ4cOAAtGvXDh555BG4ePGip6eWc1SqRH8LFwbo1AngpZcApk2jU3H697B1K0CvXgCvvgqQmkqn42Sio2m1CQAgMBDg6lXjeNeuiToMwzAMk4th0SQxY8YMGDp0KLz44otQv359+OKLL6Bq1aowe/ZsT08t65Qta69emzb098knycD7o48AbtwAuH4doHp1UW/LFoAePQCmTweYMgWgSBGyh9KIjAQ4ckT4h2rVCiAuDmDPHlFn927KYx9SDMMwTB6ARdN/JCcnw/79+6Fr165KfteuXWGnhaFyUlISxMfHKynXUqiQvXopKWS3hAjQrh2Jo759KeBvx45U5/ffaRXqqadIXN29S76dxowB2LgR4MAB8tNUpAgZkwPQ3+7daeVq1y5KL71Ebgn45BzDMAyTB2BD8P+4fv06pKWlQUXdVlHFihUhysJQedq0afDee+/lxPSyxv79APffb6/u77+TwXdyMgkfjcqVSQQBACxZQqLq558paQQFATzzDImopk0BkpJUVwcLFwKMGgWgCdPevQG++SZLj8YwDMMwOQWLJh1eOqNkRDTkaUyYMAHGjh2bfh8fHw9Vq1bN1vllO+++S8kZf/yRub7LlCH/TQzDMAyTB2HR9B/lypWDQoUKGVaVoqOjDatPGr6+vuDr65sT02MYhmEYxsOwTdN/+Pj4QLNmzWC9bMwMAOvXr4fWed1QuU0bigenpUWLyJ0AwzAMwzC24ZUmibFjx8KAAQOgefPm0KpVK/juu+/g4sWLMGzYME9PLWv8+699myaGYRiGYUxh0STx7LPPQkxMDLz//vsQGRkJwcHBsHr1aqguH7VnGIZhGKZAwqJJx6uvvgqvvvqqp6fBMAzDMEwug22aGIZhGIZhbMCiiWEYhmEYxgYsmhiGYRiGYWzAoolhGIZhGMYGLJoYhmEYhmFswKKJYRiGYRjGBiyaGIZhGIZhbMCiKScpVw6gaNGcHbNoURqXYRiGYZgswc4tc5Jq1QBOngS4fj3nxixXjsZlGIZhGCZLsGhyI4gIAADx8fHWlUqVopSTOJsPwzAMwxRwtO+29h23gkWTG7l16xYAAFStWtXDM2EYhmEYxlVu3boFAQEBluVemJGsYmzjcDggIiIC/P39wcvLy239xsfHQ9WqVeHSpUtQsmRJt/WbH+B34xx+P87h9+Mcfj/O4fdjTV57N4gIt27dgqCgIPD2tjb35pUmN+Lt7Q1VqlTJtv5LliyZJ/7h8wT8bpzD78c5/H6cw+/HOfx+rMlL78bZCpMGn55jGIZhGIaxAYsmhmEYhmEYG7BoygP4+vrClClTwNfX19NTyXXwu3EOvx/n8PtxDr8f5/D7sSa/vhs2BGcYhmEYhrEBrzQxDMMwDMPYgEUTwzAMwzCMDVg0MQzDMAzD2IBFE8MwDMMwjA1YNOVyZs2aBTVr1oSiRYtCs2bNYPv27Z6eUpbZtm0b9OrVC4KCgsDLywv+/PNPpRwR4d1334WgoCDw8/ODhx56CI4eParUSUpKgpEjR0K5cuWgePHi0Lt3b7h8+bJSJzY2FgYMGAABAQEQEBAAAwYMgJs3byp1Ll68CL169YLixYtDuXLlYNSoUZCcnJwdj22LadOmwQMPPAD+/v5QoUIFePzxx+HkyZNKnYL8fmbPng2NGzdOd5jXqlUrWLNmTXp5QX43eqZNmwZeXl7w+uuvp+cV5Pfz7rvvgpeXl5ICAwPTywvyu9G4cuUK9O/fH8qWLQvFihWDpk2bwv79+9PL+R0BADK5lsWLF2ORIkVw7ty5eOzYMRw9ejQWL14cw8PDPT21LLF69WqcNGkSLl26FAEAly9frpRPnz4d/f39cenSpRgWFobPPvssVqpUCePj49PrDBs2DCtXrozr16/H0NBQ7NixIzZp0gRTU1PT63Tv3h2Dg4Nx586duHPnTgwODsaePXuml6empmJwcDB27NgRQ0NDcf369RgUFIQjRozI9ndgRbdu3fDHH3/EI0eO4MGDB7FHjx5YrVo1vH37dnqdgvx+VqxYgatWrcKTJ0/iyZMnceLEiVikSBE8cuQIIhbsdyOzZ88erFGjBjZu3BhHjx6dnl+Q38+UKVOwYcOGGBkZmZ6io6PTywvyu0FEvHHjBlavXh0HDx6Mu3fvxvPnz+OGDRvwzJkz6XUK+jtCRGTRlIt58MEHcdiwYUpevXr18K233vLQjNyPXjQ5HA4MDAzE6dOnp+clJiZiQEAAzpkzBxERb968iUWKFMHFixen17ly5Qp6e3vj2rVrERHx2LFjCAC4a9eu9DohISEIAHjixAlEJPHm7e2NV65cSa+zaNEi9PX1xbi4uGx5XleJjo5GAMCtW7ciIr8fM0qXLo3ff/89v5v/uHXrFtauXRvXr1+PHTp0SBdNBf39TJkyBZs0aWJaVtDfDSLim2++iW3btrUs53dE8PZcLiU5ORn2798PXbt2VfK7du0KO3fu9NCssp/z589DVFSU8ty+vr7QoUOH9Ofev38/pKSkKHWCgoIgODg4vU5ISAgEBARAixYt0uu0bNkSAgIClDrBwcEQFBSUXqdbt26QlJSkLEl7kri4OAAAKFOmDADw+5FJS0uDxYsXw507d6BVq1b8bv7jtddegx49ekCXLl2UfH4/AKdPn4agoCCoWbMm9O3bF86dOwcA/G4AAFasWAHNmzeHp59+GipUqAD33XcfzJ07N72c3xHBoimXcv36dUhLS4OKFSsq+RUrVoSoqCgPzSr70Z7N2XNHRUWBj48PlC5d2mmdChUqGPqvUKGCUkc/TunSpcHHxydXvGNEhLFjx0Lbtm0hODgYAPj9AACEhYVBiRIlwNfXF4YNGwbLly+HBg0a8LsBgMWLF0NoaChMmzbNUFbQ30+LFi1g/vz58M8//8DcuXMhKioKWrduDTExMQX+3QAAnDt3DmbPng21a9eGf/75B4YNGwajRo2C+fPnAwD/86NR2KOjMxni5eWl3COiIS8/kpnn1tcxq5+ZOp5ixIgRcPjwYdixY4ehrCC/n7p168LBgwfh5s2bsHTpUhg0aBBs3bo1vbygvptLly7B6NGjYd26dVC0aFHLegX1/TzyyCPp140aNYJWrVrBvffeCz///DO0bNkSAAruuwEAcDgc0Lx5c5g6dSoAANx3331w9OhRmD17NgwcODC9XkF+RwC80pRrKVeuHBQqVMigqqOjow0KPD+hnWZx9tyBgYGQnJwMsbGxTutcvXrV0P+1a9eUOvpxYmNjISUlxePveOTIkbBixQrYvHkzVKlSJT2f3w+Aj48P1KpVC5o3bw7Tpk2DJk2awJdfflng383+/fshOjoamjVrBoULF4bChQvD1q1b4auvvoLChQunz6ugvh89xYsXh0aNGsHp06cL/D87AACVKlWCBg0aKHn169eHixcvAgD/t0eDRVMuxcfHB5o1awbr169X8tevXw+tW7f20Kyyn5o1a0JgYKDy3MnJybB169b0527WrBkUKVJEqRMZGQlHjhxJr9OqVSuIi4uDPXv2pNfZvXs3xMXFKXWOHDkCkZGR6XXWrVsHvr6+0KxZs2x9TisQEUaMGAHLli2DTZs2Qc2aNZXygv5+zEBESEpKKvDvpnPnzhAWFgYHDx5MT82bN4d+/frBwYMH4Z577inQ70dPUlISHD9+HCpVqlTg/9kBAGjTpo3BvcmpU6egevXqAMD/7UknZ+zNmcyguRyYN28eHjt2DF9//XUsXrw4XrhwwdNTyxK3bt3CAwcO4IEDBxAAcMaMGXjgwIF0VwrTp0/HgIAAXLZsGYaFheFzzz1neqy1SpUquGHDBgwNDcVOnTqZHmtt3LgxhoSEYEhICDZq1Mj0WGvnzp0xNDQUN2zYgFWqVPHosdbhw4djQEAAbtmyRTkanZCQkF6nIL+fCRMm4LZt2/D8+fN4+PBhnDhxInp7e+O6desQsWC/GzPk03OIBfv9jBs3Drds2YLnzp3DXbt2Yc+ePdHf3z/9v6cF+d0gkpuKwoUL40cffYSnT5/GhQsXYrFixfCXX35Jr1PQ3xEiuxzI9cycOROrV6+OPj4+eP/996cfPc/LbN68GQHAkAYNGoSIdLR1ypQpGBgYiL6+vti+fXsMCwtT+rh79y6OGDECy5Qpg35+ftizZ0+8ePGiUicmJgb79euH/v7+6O/vj/369cPY2FilTnh4OPbo0QP9/PywTJkyOGLECExMTMzOx3eK2XsBAPzxxx/T6xTk9zNkyJD0fx/Kly+PnTt3ThdMiAX73ZihF00F+f1oPoWKFCmCQUFB+MQTT+DRo0fTywvyu9FYuXIlBgcHo6+vL9arVw+/++47pZzfEaIXIqJn1rgYhmEYhmHyDmzTxDAMwzAMYwMWTQzDMAzDMDZg0cQwDMMwDGMDFk0MwzAMwzA2YNHEMAzDMAxjAxZNDMMwDMMwNmDRxDAMwzAMYwMWTQzDMAzDMDYo7OkJMAzDeIqdO3fCq6++alrWvXt32LdvH1y/ft20fM+ePTBnzhz44YcfTMvffvtteOqpp9w2V4ZhPA+LJoZhCizx8fHw+OOPw7vvvqvkX7hwAd566y24ffs2HDx40NDuoYceAofDAREREfDFF1/AQw89pJT/9NNPlmKLYZi8C2/PMQzDMAzD2IBFE8MwDMMwjA1YNDEMwzAMw9iARRPDMAzDMIwNWDQxDMMwDMPYgEUTwzAMwzCMDVg0MQzDMAzD2IBFE8MwDMMwjA1YNDEMwzAMw9iARRPDMAzDMIwNOIwKwzAFloCAAPj777/h77//NpR169YNbt68Cc2bNzdt6+3tDVWqVIHx48eblk+cONGtc2UYxvN4ISJ6ehIMwzAMwzC5Hd6eYxiGYRiGsQGLJoZhGIZhGBuwaGIYhmEYhrEBiyaGYRiGYRgbsGhiGIZhGIaxAYsmhmEYhmEYG7BoYhiGYRiGsQGLJoZhGIZhGBuwaGIYhmEYhrHB/wPznj/AUIjMxwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Main program\n",
    "clear = lambda: None\n",
    "clear()\n",
    "clc = lambda: None\n",
    "clc()\n",
    "\n",
    "# Example usage\n",
    "# Load your data (assuming X is your city coordinates)\n",
    "# X = np.loadtxt('your_data.txt')\n",
    "\n",
    "# Initialize parameters\n",
    "NIND = 100\n",
    "MAXGEN = 300\n",
    "Pc = 0.9\n",
    "Pm = 0.05\n",
    "GGAP = 0.9\n",
    "D = distance(X)\n",
    "N = D.shape[0]\n",
    "\n",
    "# Initialize population\n",
    "Chrom = InitPop(NIND, N)\n",
    "\n",
    "# Plot coordinates\n",
    "plt.figure()\n",
    "plt.plot(X[:, 0], X[:, 1], 'o')\n",
    "\n",
    "# Plot random solution\n",
    "DrawPath(Chrom[0, :], X)\n",
    "\n",
    "# Output random solution path and total distance\n",
    "print('Initial random solution:')\n",
    "OutputPath(Chrom[0, :])\n",
    "\n",
    "Rlength = path_length(D, np.expand_dims(Chrom[0, :], axis=0))\n",
    "\n",
    "print('Total distance:', Rlength)\n",
    "print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\n",
    "\n",
    "# Optimization\n",
    "gen = 0\n",
    "plt.figure()\n",
    "plt.title('Optimization Process')\n",
    "plt.xlabel('Generation')\n",
    "plt.ylabel('Best Value')\n",
    "ObjV = path_length(D, Chrom)\n",
    "preObjV = np.min(ObjV)\n",
    "\n",
    "while gen < MAXGEN:\n",
    "    # Calculate fitness\n",
    "    ObjV = path_length(D, Chrom)\n",
    "\n",
    "    # Plot optimization progress\n",
    "    plt.plot([gen-1, gen], [preObjV, np.min(ObjV)], color='blue')\n",
    "\n",
    "    preObjV = np.min(ObjV)\n",
    "    FitnV = Fitness(ObjV)\n",
    "\n",
    "    # Selection\n",
    "    SelCh = select(Chrom, FitnV, GGAP)\n",
    "\n",
    "    # Crossover\n",
    "    SelCh = Recombin(SelCh, Pc)\n",
    "\n",
    "    # Mutation\n",
    "    SelCh = Mutate(SelCh, Pm)\n",
    "\n",
    "    # Evolution reversal\n",
    "    SelCh = reverse(SelCh, D)\n",
    "\n",
    "    # Reinsert offspring into the new population\n",
    "    Chrom = reins(Chrom, SelCh, ObjV)\n",
    "\n",
    "    # Update iteration count\n",
    "    gen += 1\n",
    "\n",
    "# Plot the best solution\n",
    "ObjV = path_length(D, Chrom)\n",
    "minObjV, minInd = np.min(ObjV), np.argmin(ObjV)\n",
    "DrawPath(Chrom[minInd, :], X)\n",
    "\n",
    "# Output the best solution path and total distance\n",
    "print('Best solution:')\n",
    "OutputPath(Chrom[minInd, :])\n",
    "print('Total distance:', ObjV[minInd])\n",
    "print('-------------------------------------------------------------')\n",
    "\n",
    "# Display the plots\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96fd6815-1b99-4e85-9ace-a72a551cc296",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
